src/TortoiseProc/ProjectProperties.cpp

   1 // TortoiseSVN - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2003-2008 - 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 "TortoiseProc.h"
  21 #include "UnicodeUtils.h"
  22 #include "ProjectProperties.h"
  23 //#include "GitProperties.h"
  24 #include "TGitPath.h"
  25 #include <regex>
  26 #include "git.h"
  27
  28 using namespace std;
  29
  30
  31 ProjectProperties::ProjectProperties(void)
  32 {
  33         bNumber = TRUE;
  34         bWarnIfNoIssue = FALSE;
  35         nLogWidthMarker = 0;
  36         nMinLogSize = 0;
  37         nMinLockMsgSize = 0;
  38         bFileListInEnglish = TRUE;
  39         bAppend = TRUE;
  40         lProjectLanguage = 0;
  41 }
  42
  43 ProjectProperties::~ProjectProperties(void)
  44 {
  45 }
  46
  47
  48 BOOL ProjectProperties::ReadPropsPathList(const CTGitPathList& pathList)
  49 {
  50         for(int nPath = 0; nPath < pathList.GetCount(); nPath++)
  51         {
  52                 if (ReadProps(pathList[nPath]))
  53                 {
  54                         return TRUE;
  55                 }
  56         }
  57         return FALSE;
  58 }
  59
  60 BOOL ProjectProperties::GetStringProps(CString &prop,TCHAR *key,bool bRemoveCR)
  61 {
  62         CString cmd,output;
  63         output.Empty();
  64
  65         cmd.Format(_T("git.exe config %s"),key);
  66         int start = 0;
  67         if(g_Git.Run(cmd,&output,CP_ACP))
  68         {
  69                 return FALSE;
  70         }
  71         if(bRemoveCR)
  72                 prop = output.Tokenize(_T("\n"),start);
  73         else
  74                 prop = output;
  75
  76         return TRUE;
  77
  78 }
  79
  80 BOOL ProjectProperties::GetBOOLProps(BOOL &b,TCHAR *key)
  81 {
  82         CString str,low;
  83         if(!GetStringProps(str,key))
  84                 return FALSE;
  85
  86         low=str.MakeLower();
  87         if(low == _T("true"))
  88                 b=true;
  89         else
  90                 b=false;
  91
  92         return true;
  93
  94 }
  95 BOOL ProjectProperties::ReadProps(CTGitPath path)
  96 {
  97         CString sPropVal;
  98
  99         GetStringProps(this->sLabel,BUGTRAQPROPNAME_LABEL);
 100         GetStringProps(this->sMessage,BUGTRAQPROPNAME_MESSAGE);
 101         GetStringProps(this->sUrl,BUGTRAQPROPNAME_URL);
 102
 103         GetBOOLProps(this->bWarnIfNoIssue,BUGTRAQPROPNAME_WARNIFNOISSUE);
 104         GetBOOLProps(this->bNumber,BUGTRAQPROPNAME_NUMBER);
 105         GetBOOLProps(this->bAppend,BUGTRAQPROPNAME_APPEND);
 106
 107         GetStringProps(sPropVal,BUGTRAQPROPNAME_LOGREGEX,false);
 108
 109         sCheckRe = sPropVal;
 110         if (sCheckRe.Find('\n')>=0)
 111         {
 112                 sBugIDRe = sCheckRe.Mid(sCheckRe.Find('\n')).Trim();
 113                 sCheckRe = sCheckRe.Left(sCheckRe.Find('\n')).Trim();
 114         }
 115         if (!sCheckRe.IsEmpty())
 116         {
 117                 sCheckRe = sCheckRe.Trim();
 118         }
 119         return TRUE;
 120
 121
 122 #if 0
 123         BOOL bFoundBugtraqLabel = FALSE;
 124         BOOL bFoundBugtraqMessage = FALSE;
 125         BOOL bFoundBugtraqNumber = FALSE;
 126         BOOL bFoundBugtraqLogRe = FALSE;
 127         BOOL bFoundBugtraqURL = FALSE;
 128         BOOL bFoundBugtraqWarnIssue = FALSE;
 129         BOOL bFoundBugtraqAppend = FALSE;
 130         BOOL bFoundLogWidth = FALSE;
 131         BOOL bFoundLogTemplate = FALSE;
 132         BOOL bFoundMinLogSize = FALSE;
 133         BOOL bFoundMinLockMsgSize = FALSE;
 134         BOOL bFoundFileListEnglish = FALSE;
 135         BOOL bFoundProjectLanguage = FALSE;
 136         BOOL bFoundUserFileProps = FALSE;
 137         BOOL bFoundUserDirProps = FALSE;
 138         BOOL bFoundWebViewRev = FALSE;
 139         BOOL bFoundWebViewPathRev = FALSE;
 140         BOOL bFoundAutoProps = FALSE;
 141         BOOL bFoundLogSummary = FALSE;
 142
 143         if (!path.IsDirectory())
 144                 path = path.GetContainingDirectory();
 145
 146         for (;;)
 147         {
 148                 GitProperties props(path, GitRev::REV_WC, false);
 149                 for (int i=0; i<props.GetCount(); ++i)
 150                 {
 151                         CString sPropName = props.GetItemName(i).c_str();
 152                         CString sPropVal = CUnicodeUtils::GetUnicode(((char *)props.GetItemValue(i).c_str()));
 153                         if ((!bFoundBugtraqLabel)&&(sPropName.Compare(BUGTRAQPROPNAME_LABEL)==0))
 154                         {
 155                                 sLabel = sPropVal;
 156                                 bFoundBugtraqLabel = TRUE;
 157                         }
 158                         if ((!bFoundBugtraqMessage)&&(sPropName.Compare(BUGTRAQPROPNAME_MESSAGE)==0))
 159                         {
 160                                 sMessage = sPropVal;
 161                                 bFoundBugtraqMessage = TRUE;
 162                         }
 163                         if ((!bFoundBugtraqNumber)&&(sPropName.Compare(BUGTRAQPROPNAME_NUMBER)==0))
 164                         {
 165                                 CString val;
 166                                 val = sPropVal;
 167                                 val = val.Trim(_T(" \n\r\t"));
 168                                 if ((val.CompareNoCase(_T("false"))==0)||(val.CompareNoCase(_T("no"))==0))
 169                                         bNumber = FALSE;
 170                                 else
 171                                         bNumber = TRUE;
 172                                 bFoundBugtraqNumber = TRUE;
 173                         }
 174                         if ((!bFoundBugtraqLogRe)&&(sPropName.Compare(BUGTRAQPROPNAME_LOGREGEX)==0))
 175                         {
 176                                 sCheckRe = sPropVal;
 177                                 if (sCheckRe.Find('\n')>=0)
 178                                 {
 179                                         sBugIDRe = sCheckRe.Mid(sCheckRe.Find('\n')).Trim();
 180                                         sCheckRe = sCheckRe.Left(sCheckRe.Find('\n')).Trim();
 181                                 }
 182                                 if (!sCheckRe.IsEmpty())
 183                                 {
 184                                         sCheckRe = sCheckRe.Trim();
 185                                 }
 186                                 bFoundBugtraqLogRe = TRUE;
 187                         }
 188                         if ((!bFoundBugtraqURL)&&(sPropName.Compare(BUGTRAQPROPNAME_URL)==0))
 189                         {
 190                                 sUrl = sPropVal;
 191                                 bFoundBugtraqURL = TRUE;
 192                         }
 193                         if ((!bFoundBugtraqWarnIssue)&&(sPropName.Compare(BUGTRAQPROPNAME_WARNIFNOISSUE)==0))
 194                         {
 195                                 CString val;
 196                                 val = sPropVal;
 197                                 val = val.Trim(_T(" \n\r\t"));
 198                                 if ((val.CompareNoCase(_T("true"))==0)||(val.CompareNoCase(_T("yes"))==0))
 199                                         bWarnIfNoIssue = TRUE;
 200                                 else
 201                                         bWarnIfNoIssue = FALSE;
 202                                 bFoundBugtraqWarnIssue = TRUE;
 203                         }
 204                         if ((!bFoundBugtraqAppend)&&(sPropName.Compare(BUGTRAQPROPNAME_APPEND)==0))
 205                         {
 206                                 CString val;
 207                                 val = sPropVal;
 208                                 val = val.Trim(_T(" \n\r\t"));
 209                                 if ((val.CompareNoCase(_T("true"))==0)||(val.CompareNoCase(_T("yes"))==0))
 210                                         bAppend = TRUE;
 211                                 else
 212                                         bAppend = FALSE;
 213                                 bFoundBugtraqAppend = TRUE;
 214                         }
 215                         if ((!bFoundLogWidth)&&(sPropName.Compare(PROJECTPROPNAME_LOGWIDTHLINE)==0))
 216                         {
 217                                 CString val;
 218                                 val = sPropVal;
 219                                 if (!val.IsEmpty())
 220                                 {
 221                                         nLogWidthMarker = _ttoi(val);
 222                                 }
 223                                 bFoundLogWidth = TRUE;
 224                         }
 225                         if ((!bFoundLogTemplate)&&(sPropName.Compare(PROJECTPROPNAME_LOGTEMPLATE)==0))
 226                         {
 227                                 sLogTemplate = sPropVal;
 228                                 sLogTemplate.Replace(_T("\r"), _T(""));
 229                                 sLogTemplate.Replace(_T("\n"), _T("\r\n"));
 230                                 bFoundLogTemplate = TRUE;
 231                         }
 232                         if ((!bFoundMinLogSize)&&(sPropName.Compare(PROJECTPROPNAME_LOGMINSIZE)==0))
 233                         {
 234                                 CString val;
 235                                 val = sPropVal;
 236                                 if (!val.IsEmpty())
 237                                 {
 238                                         nMinLogSize = _ttoi(val);
 239                                 }
 240                                 bFoundMinLogSize = TRUE;
 241                         }
 242                         if ((!bFoundMinLockMsgSize)&&(sPropName.Compare(PROJECTPROPNAME_LOCKMSGMINSIZE)==0))
 243                         {
 244                                 CString val;
 245                                 val = sPropVal;
 246                                 if (!val.IsEmpty())
 247                                 {
 248                                         nMinLockMsgSize = _ttoi(val);
 249                                 }
 250                                 bFoundMinLockMsgSize = TRUE;
 251                         }
 252                         if ((!bFoundFileListEnglish)&&(sPropName.Compare(PROJECTPROPNAME_LOGFILELISTLANG)==0))
 253                         {
 254                                 CString val;
 255                                 val = sPropVal;
 256                                 val = val.Trim(_T(" \n\r\t"));
 257                                 if ((val.CompareNoCase(_T("false"))==0)||(val.CompareNoCase(_T("no"))==0))
 258                                         bFileListInEnglish = TRUE;
 259                                 else
 260                                         bFileListInEnglish = FALSE;
 261                                 bFoundFileListEnglish = TRUE;
 262                         }
 263                         if ((!bFoundProjectLanguage)&&(sPropName.Compare(PROJECTPROPNAME_PROJECTLANGUAGE)==0))
 264                         {
 265                                 CString val;
 266                                 val = sPropVal;
 267                                 if (!val.IsEmpty())
 268                                 {
 269                                         LPTSTR strEnd;
 270                                         lProjectLanguage = _tcstol(val, &strEnd, 0);
 271                                 }
 272                                 bFoundProjectLanguage = TRUE;
 273                         }
 274                         if ((!bFoundUserFileProps)&&(sPropName.Compare(PROJECTPROPNAME_USERFILEPROPERTY)==0))
 275                         {
 276                                 sFPPath = sPropVal;
 277                                 sFPPath.Replace(_T("\r\n"), _T("\n"));
 278                                 bFoundUserFileProps = TRUE;
 279                         }
 280                         if ((!bFoundUserDirProps)&&(sPropName.Compare(PROJECTPROPNAME_USERDIRPROPERTY)==0))
 281                         {
 282                                 sDPPath = sPropVal;
 283                                 sDPPath.Replace(_T("\r\n"), _T("\n"));
 284                                 bFoundUserDirProps = TRUE;
 285                         }
 286                         if ((!bFoundAutoProps)&&(sPropName.Compare(PROJECTPROPNAME_AUTOPROPS)==0))
 287                         {
 288                                 sAutoProps = sPropVal;
 289                                 sAutoProps.Replace(_T("\r\n"), _T("\n"));
 290                                 bFoundAutoProps = TRUE;
 291                         }
 292                         if ((!bFoundWebViewRev)&&(sPropName.Compare(PROJECTPROPNAME_WEBVIEWER_REV)==0))
 293                         {
 294                                 sWebViewerRev = sPropVal;
 295                                 bFoundWebViewRev = TRUE;
 296                         }
 297                         if ((!bFoundWebViewPathRev)&&(sPropName.Compare(PROJECTPROPNAME_WEBVIEWER_PATHREV)==0))
 298                         {
 299                                 sWebViewerPathRev = sPropVal;
 300                                 bFoundWebViewPathRev = TRUE;
 301                         }
 302                         if ((!bFoundLogSummary)&&(sPropName.Compare(PROJECTPROPNAME_LOGSUMMARY)==0))
 303                         {
 304                                 sLogSummaryRe = sPropVal;
 305                                 bFoundLogSummary = TRUE;
 306                         }
 307                 }
 308                 if (PathIsRoot(path.GetWinPath()))
 309                         return FALSE;
 310                 propsPath = path;
 311                 path = path.GetContainingDirectory();
 312                 if ((!path.HasAdminDir())||(path.IsEmpty()))
 313                 {
 314                         if (bFoundBugtraqLabel | bFoundBugtraqMessage | bFoundBugtraqNumber
 315                                 | bFoundBugtraqURL | bFoundBugtraqWarnIssue | bFoundLogWidth
 316                                 | bFoundLogTemplate | bFoundBugtraqLogRe | bFoundMinLockMsgSize
 317                                 | bFoundUserFileProps | bFoundUserDirProps | bFoundAutoProps
 318                                 | bFoundWebViewRev | bFoundWebViewPathRev | bFoundLogSummary)
 319                         {
 320                                 return TRUE;
 321                         }
 322                         propsPath.Reset();
 323                         return FALSE;
 324                 }
 325         }
 326 #endif
 327         return FALSE;           //never reached
 328 }
 329
 330 CString ProjectProperties::GetBugIDFromLog(CString& msg)
 331 {
 332         CString sBugID;
 333
 334         if (!sMessage.IsEmpty())
 335         {
 336                 CString sBugLine;
 337                 CString sFirstPart;
 338                 CString sLastPart;
 339                 BOOL bTop = FALSE;
 340                 if (sMessage.Find(_T("%BUGID%"))<0)
 341                         return sBugID;
 342                 sFirstPart = sMessage.Left(sMessage.Find(_T("%BUGID%")));
 343                 sLastPart = sMessage.Mid(sMessage.Find(_T("%BUGID%"))+7);
 344                 msg.TrimRight('\n');
 345                 if (msg.ReverseFind('\n')>=0)
 346                 {
 347                         if (bAppend)
 348                                 sBugLine = msg.Mid(msg.ReverseFind('\n')+1);
 349                         else
 350                         {
 351                                 sBugLine = msg.Left(msg.Find('\n'));
 352                                 bTop = TRUE;
 353                         }
 354                 }
 355                 else
 356                 {
 357                         if (bNumber)
 358                         {
 359                                 // find out if the message consists only of numbers
 360                                 bool bOnlyNumbers = true;
 361                                 for (int i=0; i<msg.GetLength(); ++i)
 362                                 {
 363                                         if (!_istdigit(msg[i]))
 364                                         {
 365                                                 bOnlyNumbers = false;
 366                                                 break;
 367                                         }
 368                                 }
 369                                 if (bOnlyNumbers)
 370                                         sBugLine = msg;
 371                         }
 372                         else
 373                                 sBugLine = msg;
 374                 }
 375                 if (sBugLine.Left(sFirstPart.GetLength()).Compare(sFirstPart)!=0)
 376                         sBugLine.Empty();
 377                 if (sBugLine.Right(sLastPart.GetLength()).Compare(sLastPart)!=0)
 378                         sBugLine.Empty();
 379                 if (sBugLine.IsEmpty())
 380                 {
 381                         if (msg.Find('\n')>=0)
 382                                 sBugLine = msg.Left(msg.Find('\n'));
 383                         if (sBugLine.Left(sFirstPart.GetLength()).Compare(sFirstPart)!=0)
 384                                 sBugLine.Empty();
 385                         if (sBugLine.Right(sLastPart.GetLength()).Compare(sLastPart)!=0)
 386                                 sBugLine.Empty();
 387                         bTop = TRUE;
 388                 }
 389                 if (sBugLine.IsEmpty())
 390                         return sBugID;
 391                 sBugID = sBugLine.Mid(sFirstPart.GetLength(), sBugLine.GetLength() - sFirstPart.GetLength() - sLastPart.GetLength());
 392                 if (bTop)
 393                 {
 394                         msg = msg.Mid(sBugLine.GetLength());
 395                         msg.TrimLeft('\n');
 396                 }
 397                 else
 398                 {
 399                         msg = msg.Left(msg.GetLength()-sBugLine.GetLength());
 400                         msg.TrimRight('\n');
 401                 }
 402         }
 403         return sBugID;
 404 }
 405
 406 BOOL ProjectProperties::FindBugID(const CString& msg, CWnd * pWnd)
 407 {
 408         size_t offset1 = 0;
 409         size_t offset2 = 0;
 410         bool bFound = false;
 411
 412         if (sUrl.IsEmpty())
 413                 return FALSE;
 414
 415         // first use the checkre string to find bug ID's in the message
 416         if (!sCheckRe.IsEmpty())
 417         {
 418                 if (!sBugIDRe.IsEmpty())
 419                 {
 420
 421                         // match with two regex strings (without grouping!)
 422                         try
 423                         {
 424                                 const tr1::wregex regCheck(sCheckRe);
 425                                 const tr1::wregex regBugID(sBugIDRe);
 426                                 const tr1::wsregex_iterator end;
 427                                 wstring s = msg;
 428                                 for (tr1::wsregex_iterator it(s.begin(), s.end(), regCheck); it != end; ++it)
 429                                 {
 430                                         // (*it)[0] is the matched string
 431                                         wstring matchedString = (*it)[0];
 432                                         ptrdiff_t matchpos = it->position(0);
 433                                         for (tr1::wsregex_iterator it2(matchedString.begin(), matchedString.end(), regBugID); it2 != end; ++it2)
 434                                         {
 435                                                 ATLTRACE(_T("matched id : %s\n"), (*it2)[0].str().c_str());
 436                                                 ptrdiff_t matchposID = it2->position(0);
 437                                                 CHARRANGE range = {(LONG)(matchpos+matchposID), (LONG)(matchpos+matchposID+(*it2)[0].str().size())};
 438                                                 pWnd->SendMessage(EM_EXSETSEL, NULL, (LPARAM)&range);
 439                                                 CHARFORMAT2 format;
 440                                                 SecureZeroMemory(&format, sizeof(CHARFORMAT2));
 441                                                 format.cbSize = sizeof(CHARFORMAT2);
 442                                                 format.dwMask = CFM_LINK;
 443                                                 format.dwEffects = CFE_LINK;
 444                                                 pWnd->SendMessage(EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&format);
 445                                                 bFound = true;
 446                                         }
 447                                 }
 448                         }
 449                         catch (exception) {}
 450                 }
 451                 else
 452                 {
 453                         try
 454                         {
 455                                 const tr1::wregex regCheck(sCheckRe);
 456                                 const tr1::wsregex_iterator end;
 457                                 wstring s = msg;
 458                                 for (tr1::wsregex_iterator it(s.begin(), s.end(), regCheck); it != end; ++it)
 459                                 {
 460                                         const tr1::wsmatch match = *it;
 461                                         // we define group 1 as the whole issue text and
 462                                         // group 2 as the bug ID
 463                                         if (match.size() >= 2)
 464                                         {
 465                                                 ATLTRACE(_T("matched id : %s\n"), wstring(match[1]).c_str());
 466                                                 CHARRANGE range = {(LONG)(match[1].first-s.begin()), (LONG)(match[1].second-s.begin())};
 467                                                 pWnd->SendMessage(EM_EXSETSEL, NULL, (LPARAM)&range);
 468                                                 CHARFORMAT2 format;
 469                                                 SecureZeroMemory(&format, sizeof(CHARFORMAT2));
 470                                                 format.cbSize = sizeof(CHARFORMAT2);
 471                                                 format.dwMask = CFM_LINK;
 472                                                 format.dwEffects = CFE_LINK;
 473                                                 pWnd->SendMessage(EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&format);
 474                                                 bFound = true;
 475                                         }
 476                                 }
 477                         }
 478                         catch (exception) {}
 479                 }
 480         }
 481         else if ((!bFound)&&(!sMessage.IsEmpty()))
 482         {
 483                 CString sBugLine;
 484                 CString sFirstPart;
 485                 CString sLastPart;
 486                 BOOL bTop = FALSE;
 487                 if (sMessage.Find(_T("%BUGID%"))<0)
 488                         return FALSE;
 489                 sFirstPart = sMessage.Left(sMessage.Find(_T("%BUGID%")));
 490                 sLastPart = sMessage.Mid(sMessage.Find(_T("%BUGID%"))+7);
 491                 CString sMsg = msg;
 492                 sMsg.TrimRight('\n');
 493                 if (sMsg.ReverseFind('\n')>=0)
 494                 {
 495                         if (bAppend)
 496                                 sBugLine = sMsg.Mid(sMsg.ReverseFind('\n')+1);
 497                         else
 498                         {
 499                                 sBugLine = sMsg.Left(sMsg.Find('\n'));
 500                                 bTop = TRUE;
 501                         }
 502                 }
 503                 else
 504                         sBugLine = sMsg;
 505                 if (sBugLine.Left(sFirstPart.GetLength()).Compare(sFirstPart)!=0)
 506                         sBugLine.Empty();
 507                 if (sBugLine.Right(sLastPart.GetLength()).Compare(sLastPart)!=0)
 508                         sBugLine.Empty();
 509                 if (sBugLine.IsEmpty())
 510                 {
 511                         if (sMsg.Find('\n')>=0)
 512                                 sBugLine = sMsg.Left(sMsg.Find('\n'));
 513                         if (sBugLine.Left(sFirstPart.GetLength()).Compare(sFirstPart)!=0)
 514                                 sBugLine.Empty();
 515                         if (sBugLine.Right(sLastPart.GetLength()).Compare(sLastPart)!=0)
 516                                 sBugLine.Empty();
 517                         bTop = TRUE;
 518                 }
 519                 if (sBugLine.IsEmpty())
 520                         return FALSE;
 521                 CString sBugIDPart = sBugLine.Mid(sFirstPart.GetLength(), sBugLine.GetLength() - sFirstPart.GetLength() - sLastPart.GetLength());
 522                 if (sBugIDPart.IsEmpty())
 523                         return FALSE;
 524                 //the bug id part can contain several bug id's, separated by commas
 525                 if (!bTop)
 526                         offset1 = sMsg.GetLength() - sBugLine.GetLength() + sFirstPart.GetLength();
 527                 else
 528                         offset1 = sFirstPart.GetLength();
 529                 sBugIDPart.Trim(_T(","));
 530                 while (sBugIDPart.Find(',')>=0)
 531                 {
 532                         offset2 = offset1 + sBugIDPart.Find(',');
 533                         CHARRANGE range = {(LONG)offset1, (LONG)offset2};
 534                         pWnd->SendMessage(EM_EXSETSEL, NULL, (LPARAM)&range);
 535                         CHARFORMAT2 format;
 536                         SecureZeroMemory(&format, sizeof(CHARFORMAT2));
 537                         format.cbSize = sizeof(CHARFORMAT2);
 538                         format.dwMask = CFM_LINK;
 539                         format.dwEffects = CFE_LINK;
 540                         pWnd->SendMessage(EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&format);
 541                         sBugIDPart = sBugIDPart.Mid(sBugIDPart.Find(',')+1);
 542                         offset1 = offset2 + 1;
 543                 }
 544                 offset2 = offset1 + sBugIDPart.GetLength();
 545                 CHARRANGE range = {(LONG)offset1, (LONG)offset2};
 546                 pWnd->SendMessage(EM_EXSETSEL, NULL, (LPARAM)&range);
 547                 CHARFORMAT2 format;
 548                 SecureZeroMemory(&format, sizeof(CHARFORMAT2));
 549                 format.cbSize = sizeof(CHARFORMAT2);
 550                 format.dwMask = CFM_LINK;
 551                 format.dwEffects = CFE_LINK;
 552                 pWnd->SendMessage(EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&format);
 553                 return TRUE;
 554         }
 555         return FALSE;
 556 }
 557
 558 std::set<CString> ProjectProperties::FindBugIDs(const CString& msg)
 559 {
 560         size_t offset1 = 0;
 561         size_t offset2 = 0;
 562         bool bFound = false;
 563         std::set<CString> bugIDs;
 564
 565         // first use the checkre string to find bug ID's in the message
 566         if (!sCheckRe.IsEmpty())
 567         {
 568                 if (!sBugIDRe.IsEmpty())
 569                 {
 570                         // match with two regex strings (without grouping!)
 571                         try
 572                         {
 573                                 const tr1::wregex regCheck(sCheckRe);
 574                                 const tr1::wregex regBugID(sBugIDRe);
 575                                 const tr1::wsregex_iterator end;
 576                                 wstring s = msg;
 577                                 for (tr1::wsregex_iterator it(s.begin(), s.end(), regCheck); it != end; ++it)
 578                                 {
 579                                         // (*it)[0] is the matched string
 580                                         wstring matchedString = (*it)[0];
 581                                         for (tr1::wsregex_iterator it2(matchedString.begin(), matchedString.end(), regBugID); it2 != end; ++it2)
 582                                         {
 583                                                 ATLTRACE(_T("matched id : %s\n"), (*it2)[0].str().c_str());
 584                                                 bugIDs.insert(CString((*it2)[0].str().c_str()));
 585                                         }
 586                                 }
 587                         }
 588                         catch (exception) {}
 589                 }
 590                 else
 591                 {
 592                         try
 593                         {
 594                                 const tr1::wregex regCheck(sCheckRe);
 595                                 const tr1::wsregex_iterator end;
 596                                 wstring s = msg;
 597                                 for (tr1::wsregex_iterator it(s.begin(), s.end(), regCheck); it != end; ++it)
 598                                 {
 599                                         const tr1::wsmatch match = *it;
 600                                         // we define group 1 as the whole issue text and
 601                                         // group 2 as the bug ID
 602                                         if (match.size() >= 2)
 603                                         {
 604                                                 ATLTRACE(_T("matched id : %s\n"), wstring(match[1]).c_str());
 605                                                 bugIDs.insert(CString(wstring(match[1]).c_str()));
 606                                         }
 607                                 }
 608                         }
 609                         catch (exception) {}
 610                 }
 611         }
 612         else if ((!bFound)&&(!sMessage.IsEmpty()))
 613         {
 614                 CString sBugLine;
 615                 CString sFirstPart;
 616                 CString sLastPart;
 617                 BOOL bTop = FALSE;
 618                 if (sMessage.Find(_T("%BUGID%"))<0)
 619                         return bugIDs;
 620                 sFirstPart = sMessage.Left(sMessage.Find(_T("%BUGID%")));
 621                 sLastPart = sMessage.Mid(sMessage.Find(_T("%BUGID%"))+7);
 622                 CString sMsg = msg;
 623                 sMsg.TrimRight('\n');
 624                 if (sMsg.ReverseFind('\n')>=0)
 625                 {
 626                         if (bAppend)
 627                                 sBugLine = sMsg.Mid(sMsg.ReverseFind('\n')+1);
 628                         else
 629                         {
 630                                 sBugLine = sMsg.Left(sMsg.Find('\n'));
 631                                 bTop = TRUE;
 632                         }
 633                 }
 634                 else
 635                         sBugLine = sMsg;
 636                 if (sBugLine.Left(sFirstPart.GetLength()).Compare(sFirstPart)!=0)
 637                         sBugLine.Empty();
 638                 if (sBugLine.Right(sLastPart.GetLength()).Compare(sLastPart)!=0)
 639                         sBugLine.Empty();
 640                 if (sBugLine.IsEmpty())
 641                 {
 642                         if (sMsg.Find('\n')>=0)
 643                                 sBugLine = sMsg.Left(sMsg.Find('\n'));
 644                         if (sBugLine.Left(sFirstPart.GetLength()).Compare(sFirstPart)!=0)
 645                                 sBugLine.Empty();
 646                         if (sBugLine.Right(sLastPart.GetLength()).Compare(sLastPart)!=0)
 647                                 sBugLine.Empty();
 648                         bTop = TRUE;
 649                 }
 650                 if (sBugLine.IsEmpty())
 651                         return bugIDs;
 652                 CString sBugIDPart = sBugLine.Mid(sFirstPart.GetLength(), sBugLine.GetLength() - sFirstPart.GetLength() - sLastPart.GetLength());
 653                 if (sBugIDPart.IsEmpty())
 654                         return bugIDs;
 655                 //the bug id part can contain several bug id's, separated by commas
 656                 if (!bTop)
 657                         offset1 = sMsg.GetLength() - sBugLine.GetLength() + sFirstPart.GetLength();
 658                 else
 659                         offset1 = sFirstPart.GetLength();
 660                 sBugIDPart.Trim(_T(","));
 661                 while (sBugIDPart.Find(',')>=0)
 662                 {
 663                         offset2 = offset1 + sBugIDPart.Find(',');
 664                         CHARRANGE range = {(LONG)offset1, (LONG)offset2};
 665                         bugIDs.insert(msg.Mid(range.cpMin, range.cpMax-range.cpMin));
 666                         sBugIDPart = sBugIDPart.Mid(sBugIDPart.Find(',')+1);
 667                         offset1 = offset2 + 1;
 668                 }
 669                 offset2 = offset1 + sBugIDPart.GetLength();
 670                 CHARRANGE range = {(LONG)offset1, (LONG)offset2};
 671                 bugIDs.insert(msg.Mid(range.cpMin, range.cpMax-range.cpMin));
 672         }
 673
 674         return bugIDs;
 675 }
 676
 677 CString ProjectProperties::FindBugID(const CString& msg)
 678 {
 679         CString sRet;
 680
 681         std::set<CString> bugIDs = FindBugIDs(msg);
 682
 683         for (std::set<CString>::iterator it = bugIDs.begin(); it != bugIDs.end(); ++it)
 684         {
 685                 sRet += *it;
 686                 sRet += _T(" ");
 687         }
 688         sRet.Trim();
 689         return sRet;
 690 }
 691
 692 CString ProjectProperties::GetBugIDUrl(const CString& sBugID)
 693 {
 694         CString ret;
 695         if (sUrl.IsEmpty())
 696                 return ret;
 697         if (!sMessage.IsEmpty() || !sCheckRe.IsEmpty())
 698         {
 699                 ret = sUrl;
 700                 ret.Replace(_T("%BUGID%"), sBugID);
 701         }
 702         return ret;
 703 }
 704
 705 BOOL ProjectProperties::CheckBugID(const CString& sID)
 706 {
 707         if (!sCheckRe.IsEmpty()&&(!bNumber)&&!sID.IsEmpty())
 708         {
 709                 CString sBugID = sID;
 710                 sBugID.Replace(_T(", "), _T(","));
 711                 sBugID.Replace(_T(" ,"), _T(","));
 712                 CString sMsg = sMessage;
 713                 sMsg.Replace(_T("%BUGID%"), sBugID);
 714                 return HasBugID(sMsg);
 715         }
 716         if (bNumber)
 717         {
 718                 // check if the revision actually _is_ a number
 719                 // or a list of numbers separated by colons
 720                 TCHAR c = 0;
 721                 int len = sID.GetLength();
 722                 for (int i=0; i<len; ++i)
 723                 {
 724                         c = sID.GetAt(i);
 725                         if ((c < '0')&&(c != ','))
 726                         {
 727                                 return FALSE;
 728                         }
 729                         if (c > '9')
 730                                 return FALSE;
 731                 }
 732         }
 733         return TRUE;
 734 }
 735
 736 BOOL ProjectProperties::HasBugID(const CString& sMessage)
 737 {
 738         if (!sCheckRe.IsEmpty())
 739         {
 740                 try
 741                 {
 742                         tr1::wregex rx(sCheckRe);
 743                         return tr1::regex_search((LPCTSTR)sMessage, rx);
 744                 }
 745                 catch (exception) {}
 746         }
 747         return FALSE;
 748 }
 749 #if 0
 750 void ProjectProperties::InsertAutoProps(Git_config_t *cfg)
 751 {
 752         // every line is an autoprop
 753         CString sPropsData = sAutoProps;
 754         bool bEnableAutoProps = false;
 755         while (!sPropsData.IsEmpty())
 756         {
 757                 int pos = sPropsData.Find('\n');
 758                 CString sLine = pos >= 0 ? sPropsData.Left(pos) : sPropsData;
 759                 sLine.Trim();
 760                 if (!sLine.IsEmpty())
 761                 {
 762                         // format is '*.something = property=value;property=value;....'
 763                         // find first '=' char
 764                         int equalpos = sLine.Find('=');
 765                         if ((equalpos >= 0)&&(sLine[0] != '#'))
 766                         {
 767                                 CString key = sLine.Left(equalpos);
 768                                 CString value = sLine.Mid(equalpos);
 769                                 key.Trim(_T(" ="));
 770                                 value.Trim(_T(" ="));
 771                                 Git_config_set(cfg, Git_CONFIG_SECTION_AUTO_PROPS, (LPCSTR)CUnicodeUtils::GetUTF8(key), (LPCSTR)CUnicodeUtils::GetUTF8(value));
 772                                 bEnableAutoProps = true;
 773                         }
 774                 }
 775                 if (pos >= 0)
 776                         sPropsData = sPropsData.Mid(pos).Trim();
 777                 else
 778                         sPropsData.Empty();
 779         }
 780         if (bEnableAutoProps)
 781                 Git_config_set(cfg, Git_CONFIG_SECTION_MISCELLANY, Git_CONFIG_OPTION_ENABLE_AUTO_PROPS, "yes");
 782 }
 783 #endif
 784
 785 bool ProjectProperties::AddAutoProps(const CTGitPath& path)
 786 {
 787         if (!path.IsDirectory())
 788                 return true;    // no error, but nothing to do
 789
 790         bool bRet = true;
 791
 792         char buf[1024] = {0};
 793 #if 0
 794         GitProperties props(path, GitRev::REV_WC, false);
 795         if (!sLabel.IsEmpty())
 796                 bRet = props.Add(BUGTRAQPROPNAME_LABEL, WideToMultibyte((LPCTSTR)sLabel)) && bRet;
 797         if (!sMessage.IsEmpty())
 798                 bRet = props.Add(BUGTRAQPROPNAME_MESSAGE, WideToMultibyte((LPCTSTR)sMessage)) && bRet;
 799         if (!bNumber)
 800                 bRet = props.Add(BUGTRAQPROPNAME_NUMBER, "false") && bRet;
 801         if (!sCheckRe.IsEmpty())
 802                 bRet = props.Add(BUGTRAQPROPNAME_LOGREGEX, WideToMultibyte((LPCTSTR)(sCheckRe + _T("\n") + sBugIDRe))) && bRet;
 803         if (!sUrl.IsEmpty())
 804                 bRet = props.Add(BUGTRAQPROPNAME_URL, WideToMultibyte((LPCTSTR)sUrl)) && bRet;
 805         if (bWarnIfNoIssue)
 806                 bRet = props.Add(BUGTRAQPROPNAME_WARNIFNOISSUE, "true") && bRet;
 807         if (!bAppend)
 808                 bRet = props.Add(BUGTRAQPROPNAME_APPEND, "false") && bRet;
 809         if (nLogWidthMarker)
 810         {
 811                 sprintf_s(buf, sizeof(buf), "%ld", nLogWidthMarker);
 812                 bRet = props.Add(PROJECTPROPNAME_LOGWIDTHLINE, buf) && bRet;
 813         }
 814         if (!sLogTemplate.IsEmpty())
 815                 bRet = props.Add(PROJECTPROPNAME_LOGTEMPLATE, WideToMultibyte((LPCTSTR)sLogTemplate)) && bRet;
 816         if (nMinLogSize)
 817         {
 818                 sprintf_s(buf, sizeof(buf), "%ld", nMinLogSize);
 819                 bRet = props.Add(PROJECTPROPNAME_LOGMINSIZE, buf) && bRet;
 820         }
 821         if (nMinLockMsgSize)
 822         {
 823                 sprintf_s(buf, sizeof(buf), "%ld", nMinLockMsgSize);
 824                 bRet = props.Add(PROJECTPROPNAME_LOCKMSGMINSIZE, buf) && bRet;
 825         }
 826         if (!bFileListInEnglish)
 827                 bRet = props.Add(PROJECTPROPNAME_LOGFILELISTLANG, "false") && bRet;
 828         if (lProjectLanguage)
 829         {
 830                 sprintf_s(buf, sizeof(buf), "%ld", lProjectLanguage);
 831                 bRet = props.Add(PROJECTPROPNAME_PROJECTLANGUAGE, buf) && bRet;
 832         }
 833         if (!sFPPath.IsEmpty())
 834                 bRet = props.Add(PROJECTPROPNAME_USERFILEPROPERTY, WideToMultibyte((LPCTSTR)sFPPath)) && bRet;
 835         if (!sDPPath.IsEmpty())
 836                 bRet = props.Add(PROJECTPROPNAME_USERDIRPROPERTY, WideToMultibyte((LPCTSTR)sDPPath)) && bRet;
 837         if (!sWebViewerRev.IsEmpty())
 838                 bRet = props.Add(PROJECTPROPNAME_WEBVIEWER_REV, WideToMultibyte((LPCTSTR)sWebViewerRev)) && bRet;
 839         if (!sWebViewerPathRev.IsEmpty())
 840                 bRet = props.Add(PROJECTPROPNAME_WEBVIEWER_PATHREV, WideToMultibyte((LPCTSTR)sWebViewerPathRev)) && bRet;
 841         if (!sAutoProps.IsEmpty())
 842                 bRet = props.Add(PROJECTPROPNAME_AUTOPROPS, WideToMultibyte((LPCTSTR)sAutoProps)) && bRet;
 843 #endif
 844         return bRet;
 845 }
 846
 847 CString ProjectProperties::GetLogSummary(const CString& sMessage)
 848 {
 849         CString sRet;
 850
 851         if (!sLogSummaryRe.IsEmpty())
 852         {
 853                 try
 854                 {
 855                         const tr1::wregex regSum(sLogSummaryRe);
 856                         const tr1::wsregex_iterator end;
 857                         wstring s = sMessage;
 858                         for (tr1::wsregex_iterator it(s.begin(), s.end(), regSum); it != end; ++it)
 859                         {
 860                                 const tr1::wsmatch match = *it;
 861                                 // we define the first group as the summary text
 862                                 if ((*it).size() >= 1)
 863                                 {
 864                                         ATLTRACE(_T("matched summary : %s\n"), wstring(match[0]).c_str());
 865                                         sRet += (CString(wstring(match[1]).c_str()));
 866                                 }
 867                         }
 868                 }
 869                 catch (exception) {}
 870         }
 871         sRet.Trim();
 872
 873         return sRet;
 874 }
 875
 876 CString ProjectProperties::MakeShortMessage(const CString& message)
 877 {
 878         bool bFoundShort = true;
 879         CString sShortMessage = GetLogSummary(message);
 880         if (sShortMessage.IsEmpty())
 881         {
 882                 bFoundShort = false;
 883                 sShortMessage = message;
 884         }
 885         // Remove newlines and tabs 'cause those are not shown nicely in the list control
 886         sShortMessage.Replace(_T("\r"), _T(""));
 887         sShortMessage.Replace(_T("\t"), _T(" "));
 888
 889         // Suppose the first empty line separates 'summary' from the rest of the message.
 890         int found = sShortMessage.Find(_T("\n\n"));
 891         // To avoid too short 'short' messages
 892         // (e.g. if the message looks something like "Bugfix:\n\n*done this\n*done that")
 893         // only use the empty newline as a separator if it comes after at least 15 chars.
 894         if ((!bFoundShort)&&(found >= 15))
 895         {
 896                 sShortMessage = sShortMessage.Left(found);
 897         }
 898         sShortMessage.Replace('\n', ' ');
 899         return sShortMessage;
 900 }
 901
 902 #ifdef DEBUG
 903 static class PropTest
 904 {
 905 public:
 906         PropTest()
 907         {
 908                 CString msg = _T("this is a test logmessage: issue 222\nIssue #456, #678, 901  #456");
 909                 CString sUrl = _T("http://tortoiseGit.tigris.org/issues/show_bug.cgi?id=%BUGID%");
 910                 CString sCheckRe = _T("[Ii]ssue #?(\\d+)(,? ?#?(\\d+))+");
 911                 CString sBugIDRe = _T("(\\d+)");
 912                 ProjectProperties props;
 913                 props.sCheckRe = _T("PAF-[0-9]+");
 914                 props.sUrl = _T("http://tortoiseGit.tigris.org/issues/show_bug.cgi?id=%BUGID%");
 915                 CString sRet = props.FindBugID(_T("This is a test for PAF-88"));
 916                 ATLASSERT(sRet.IsEmpty());
 917                 props.sCheckRe = _T("[Ii]ssue #?(\\d+)");
 918                 sRet = props.FindBugID(_T("Testing issue #99"));
 919                 sRet.Trim();
 920                 ATLASSERT(sRet.Compare(_T("99"))==0);
 921                 props.sCheckRe = _T("[Ii]ssues?:?(\\s*(,|and)?\\s*#\\d+)+");
 922                 props.sBugIDRe = _T("(\\d+)");
 923                 props.sUrl = _T("http://tortoiseGit.tigris.org/issues/show_bug.cgi?id=%BUGID%");
 924                 sRet = props.FindBugID(_T("This is a test for Issue #7463,#666"));
 925                 ATLASSERT(props.HasBugID(_T("This is a test for Issue #7463,#666")));
 926                 ATLASSERT(!props.HasBugID(_T("This is a test for Issue 7463,666")));
 927                 sRet.Trim();
 928                 ATLASSERT(sRet.Compare(_T("666 7463"))==0);
 929                 props.sCheckRe = _T("^\\[(\\d+)\\].*");
 930                 props.sUrl = _T("http://tortoiseGit.tigris.org/issues/show_bug.cgi?id=%BUGID%");
 931                 sRet = props.FindBugID(_T("[000815] some stupid programming error fixed"));
 932                 sRet.Trim();
 933                 ATLASSERT(sRet.Compare(_T("000815"))==0);
 934                 props.sCheckRe = _T("\\[\\[(\\d+)\\]\\]\\]");
 935                 props.sUrl = _T("http://tortoiseGit.tigris.org/issues/show_bug.cgi?id=%BUGID%");
 936                 sRet = props.FindBugID(_T("test test [[000815]]] some stupid programming error fixed"));
 937                 sRet.Trim();
 938                 ATLASSERT(sRet.Compare(_T("000815"))==0);
 939                 ATLASSERT(props.HasBugID(_T("test test [[000815]]] some stupid programming error fixed")));
 940                 ATLASSERT(!props.HasBugID(_T("test test [000815]] some stupid programming error fixed")));
 941                 props.sLogSummaryRe = _T("\\[SUMMARY\\]:(.*)");
 942                 ATLASSERT(props.GetLogSummary(_T("[SUMMARY]: this is my summary")).Compare(_T("this is my summary"))==0);
 943         }
 944 } PropTest;
 945 #endif
 946
 947
 948