src/plugins/git/gitclient.cpp

   1 /**************************************************************************
   2 **
   3 ** This file is part of Qt Creator
   4 **
   5 ** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
   6 **
   7 ** Contact: Nokia Corporation (info@qt.nokia.com)
   8 **
   9 **
  10 ** GNU Lesser General Public License Usage
  11 **
  12 ** This file may be used under the terms of the GNU Lesser General Public
  13 ** License version 2.1 as published by the Free Software Foundation and
  14 ** appearing in the file LICENSE.LGPL included in the packaging of this file.
  15 ** Please review the following information to ensure the GNU Lesser General
  16 ** Public License version 2.1 requirements will be met:
  17 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  18 **
  19 ** In addition, as a special exception, Nokia gives you certain additional
  20 ** rights. These rights are described in the Nokia Qt LGPL Exception
  21 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  22 **
  23 ** Other Usage
  24 **
  25 ** Alternatively, this file may be used in accordance with the terms and
  26 ** conditions contained in a signed written agreement between you and Nokia.
  27 **
  28 ** If you have questions regarding the use of this file, please contact
  29 ** Nokia at info@qt.nokia.com.
  30 **
  31 **************************************************************************/
  32
  33 #include "gitclient.h"
  34 #include "gitutils.h"
  35
  36 #include "commitdata.h"
  37 #include "gitconstants.h"
  38 #include "gitplugin.h"
  39 #include "gitsubmiteditor.h"
  40 #include "gitversioncontrol.h"
  41
  42 #include <coreplugin/actionmanager/actionmanager.h>
  43 #include <coreplugin/coreconstants.h>
  44 #include <coreplugin/editormanager/editormanager.h>
  45 #include <coreplugin/icore.h>
  46 #include <coreplugin/messagemanager.h>
  47 #include <coreplugin/progressmanager/progressmanager.h>
  48 #include <coreplugin/vcsmanager.h>
  49 #include <coreplugin/id.h>
  50 #include <coreplugin/filemanager.h>
  51 #include <coreplugin/iversioncontrol.h>
  52
  53 #include <texteditor/itexteditor.h>
  54 #include <utils/qtcassert.h>
  55 #include <utils/qtcprocess.h>
  56 #include <utils/synchronousprocess.h>
  57 #include <utils/environment.h>
  58 #include <utils/fileutils.h>
  59 #include <vcsbase/command.h>
  60 #include <vcsbase/vcsbaseeditor.h>
  61 #include <vcsbase/vcsbaseeditorparameterwidget.h>
  62 #include <vcsbase/vcsbaseoutputwindow.h>
  63 #include <vcsbase/vcsbaseplugin.h>
  64
  65 #include <QtCore/QRegExp>
  66 #include <QtCore/QTemporaryFile>
  67 #include <QtCore/QTime>
  68 #include <QtCore/QFileInfo>
  69 #include <QtCore/QDir>
  70 #include <QtCore/QSignalMapper>
  71
  72 #include <QtGui/QComboBox>
  73 #include <QtGui/QMainWindow> // for msg box parent
  74 #include <QtGui/QMessageBox>
  75 #include <QtGui/QToolButton>
  76
  77 static const char kGitDirectoryC[] = ".git";
  78 static const char kBranchIndicatorC[] = "# On branch";
  79
  80 namespace Git {
  81 namespace Internal {
  82
  83 class BaseGitDiffArgumentsWidget : public VCSBase::VCSBaseEditorParameterWidget
  84 {
  85     Q_OBJECT
  86
  87 public:
  88     BaseGitDiffArgumentsWidget(GitClient *client, const QString &directory,
  89                                const QStringList &args) :
  90         m_workingDirectory(directory),
  91         m_client(client),
  92         m_args(args)
  93     {
  94         Q_ASSERT(!directory.isEmpty());
  95         Q_ASSERT(m_client);
  96
  97         mapSetting(addToggleButton(QLatin1String("--patience"), tr("Patience"),
  98                                    tr("Use the patience algorithm for calculating the differences.")),
  99                    client->settings()->boolPointer(GitSettings::diffPatienceKey));
 100         mapSetting(addToggleButton("--ignore-space-change", tr("Ignore Whitespace"),
 101                                    tr("Ignore whitespace only changes.")),
 102                    m_client->settings()->boolPointer(GitSettings::ignoreSpaceChangesInDiffKey));
 103     }
 104
 105 protected:
 106     QString m_workingDirectory;
 107     GitClient *m_client;
 108     QStringList m_args;
 109 };
 110
 111 class GitCommitDiffArgumentsWidget : public BaseGitDiffArgumentsWidget
 112 {
 113     Q_OBJECT
 114
 115 public:
 116     GitCommitDiffArgumentsWidget(Git::Internal::GitClient *client, const QString &directory,
 117                                  const QStringList &args, const QStringList &unstaged,
 118                                  const QStringList &staged) :
 119         BaseGitDiffArgumentsWidget(client, directory, args),
 120         m_unstagedFileNames(unstaged),
 121         m_stagedFileNames(staged)
 122     { }
 123
 124     void executeCommand()
 125     {
 126         m_client->diff(m_workingDirectory, m_args, m_unstagedFileNames, m_stagedFileNames);
 127     }
 128
 129 private:
 130     const QStringList m_unstagedFileNames;
 131     const QStringList m_stagedFileNames;
 132 };
 133
 134 class GitFileDiffArgumentsWidget : public BaseGitDiffArgumentsWidget
 135 {
 136     Q_OBJECT
 137 public:
 138     GitFileDiffArgumentsWidget(Git::Internal::GitClient *client, const QString &directory,
 139                                const QStringList &args, const QString &file) :
 140         BaseGitDiffArgumentsWidget(client, directory, args),
 141         m_fileName(file)
 142     { }
 143
 144     void executeCommand()
 145     {
 146         m_client->diff(m_workingDirectory, m_args, m_fileName);
 147     }
 148
 149 private:
 150     const QString m_fileName;
 151 };
 152
 153 class GitBranchDiffArgumentsWidget : public BaseGitDiffArgumentsWidget
 154 {
 155     Q_OBJECT
 156 public:
 157     GitBranchDiffArgumentsWidget(Git::Internal::GitClient *client, const QString &directory,
 158                                  const QStringList &args, const QString &branch) :
 159         BaseGitDiffArgumentsWidget(client, directory, args),
 160         m_branchName(branch)
 161     { }
 162
 163     void redoCommand()
 164     {
 165         m_client->diffBranch(m_workingDirectory, m_args, m_branchName);
 166     }
 167
 168 private:
 169     const QString m_branchName;
 170 };
 171
 172 class GitShowArgumentsWidget : public VCSBase::VCSBaseEditorParameterWidget
 173 {
 174     Q_OBJECT
 175
 176 public:
 177     GitShowArgumentsWidget(Git::Internal::GitClient *client,
 178                            const QString &directory,
 179                            const QStringList &args,
 180                            const QString &id) :
 181         m_client(client),
 182         m_workingDirectory(directory),
 183         m_args(args),
 184         m_id(id)
 185     {
 186         QList<ComboBoxItem> prettyChoices;
 187         prettyChoices << ComboBoxItem(tr("oneline"), QLatin1String("oneline"))
 188                       << ComboBoxItem(tr("short"), QLatin1String("short"))
 189                       << ComboBoxItem(tr("medium"), QLatin1String("medium"))
 190                       << ComboBoxItem(tr("full"), QLatin1String("full"))
 191                       << ComboBoxItem(tr("fuller"), QLatin1String("fuller"))
 192                       << ComboBoxItem(tr("email"), QLatin1String("email"))
 193                       << ComboBoxItem(tr("raw"), QLatin1String("raw"));
 194         mapSetting(addComboBox(QLatin1String("--pretty"), prettyChoices),
 195                    m_client->settings()->intPointer(GitSettings::showPrettyFormatKey));
 196     }
 197
 198     void executeCommand()
 199     {
 200         m_client->show(m_workingDirectory, m_id, m_args);
 201     }
 202
 203 private:
 204     GitClient *m_client;
 205     QString m_workingDirectory;
 206     QStringList m_args;
 207     QString m_id;
 208 };
 209
 210 class GitBlameArgumentsWidget : public VCSBase::VCSBaseEditorParameterWidget
 211 {
 212     Q_OBJECT
 213
 214 public:
 215     GitBlameArgumentsWidget(Git::Internal::GitClient *client,
 216                             const QString &directory,
 217                             const QStringList &args,
 218                             const QString &revision, const QString &fileName) :
 219         m_editor(0),
 220         m_client(client),
 221         m_workingDirectory(directory),
 222         m_args(args),
 223         m_revision(revision),
 224         m_fileName(fileName)
 225     {
 226         mapSetting(addToggleButton(QString(), tr("Omit Date"),
 227                                    tr("Hide the date of a change from the output.")),
 228                    m_client->settings()->boolPointer(GitSettings::omitAnnotationDateKey));
 229         mapSetting(addToggleButton(QString("-w"), tr("Ignore Whitespace"),
 230                                    tr("Ignore whitespace only changes.")),
 231                    m_client->settings()->boolPointer(GitSettings::ignoreSpaceChangesInBlameKey));
 232     }
 233
 234     void setEditor(VCSBase::VCSBaseEditorWidget *editor)
 235     {
 236         Q_ASSERT(editor);
 237         m_editor = editor;
 238     }
 239
 240     void executeCommand()
 241     {
 242         int line = -1;
 243         if (m_editor)
 244             line = m_editor->lineNumberOfCurrentEditor();
 245         m_client->blame(m_workingDirectory, m_args, m_fileName, m_revision, line);
 246     }
 247
 248 private:
 249     VCSBase::VCSBaseEditorWidget *m_editor;
 250     GitClient *m_client;
 251     QString m_workingDirectory;
 252     QStringList m_args;
 253     QString m_revision;
 254     QString m_fileName;
 255 };
 256
 257 inline Core::IEditor* locateEditor(const Core::ICore *core, const char *property, const QString &entry)
 258 {
 259     foreach (Core::IEditor *ed, core->editorManager()->openedEditors())
 260         if (ed->file()->property(property).toString() == entry)
 261             return ed;
 262     return 0;
 263 }
 264
 265 // Return converted command output, remove '\r' read on Windows
 266 static inline QString commandOutputFromLocal8Bit(const QByteArray &a)
 267 {
 268     QString output = QString::fromLocal8Bit(a);
 269     output.remove(QLatin1Char('\r'));
 270     return output;
 271 }
 272
 273 // Return converted command output split into lines
 274 static inline QStringList commandOutputLinesFromLocal8Bit(const QByteArray &a)
 275 {
 276     QString output = commandOutputFromLocal8Bit(a);
 277     const QChar newLine = QLatin1Char('\n');
 278     if (output.endsWith(newLine))
 279         output.truncate(output.size() - 1);
 280     if (output.isEmpty())
 281         return QStringList();
 282     return output.split(newLine);
 283 }
 284
 285 static inline VCSBase::VCSBaseOutputWindow *outputWindow()
 286 {
 287     return VCSBase::VCSBaseOutputWindow::instance();
 288 }
 289
 290 static inline QString msgRepositoryNotFound(const QString &dir)
 291 {
 292     return GitClient::tr("Cannot determine the repository for \"%1\".").arg(dir);
 293 }
 294
 295 static inline QString msgParseFilesFailed()
 296 {
 297     return  GitClient::tr("Cannot parse the file output.");
 298 }
 299
 300 // ---------------- GitClient
 301
 302 const char *GitClient::stashNamePrefix = "stash@{";
 303
 304 GitClient::GitClient(GitSettings *settings) :
 305     m_cachedGitVersion(0),
 306     m_msgWait(tr("Waiting for data...")),
 307     m_core(Core::ICore::instance()),
 308     m_repositoryChangedSignalMapper(0),
 309     m_settings(settings)
 310 {
 311     Q_ASSERT(settings);
 312     connect(m_core, SIGNAL(saveSettingsRequested()), this, SLOT(saveSettings()));
 313 }
 314
 315 GitClient::~GitClient()
 316 {
 317 }
 318
 319 const char *GitClient::noColorOption = "--no-color";
 320 const char *GitClient::decorateOption = "--decorate";
 321
 322 QString GitClient::findRepositoryForDirectory(const QString &dir)
 323 {
 324     // Check for ".git/config"
 325     const QString checkFile = QLatin1String(kGitDirectoryC) + QLatin1String("/config");
 326     return VCSBase::VCSBasePlugin::findRepositoryForDirectory(dir, checkFile);
 327 }
 328
 329 VCSBase::VCSBaseEditorWidget *GitClient::findExistingVCSEditor(const char *registerDynamicProperty,
 330                                                                const QString &dynamicPropertyValue) const
 331 {
 332     VCSBase::VCSBaseEditorWidget *rc = 0;
 333     Core::IEditor *outputEditor = locateEditor(m_core, registerDynamicProperty, dynamicPropertyValue);
 334     if (!outputEditor)
 335         return 0;
 336
 337     // Exists already
 338     Core::EditorManager::instance()->activateEditor(outputEditor, Core::EditorManager::ModeSwitch);
 339     outputEditor->createNew(m_msgWait);
 340     rc = VCSBase::VCSBaseEditorWidget::getVcsBaseEditor(outputEditor);
 341
 342     return rc;
 343 }
 344
 345 /* Create an editor associated to VCS output of a source file/directory
 346  * (using the file's codec). Makes use of a dynamic property to find an
 347  * existing instance and to reuse it (in case, say, 'git diff foo' is
 348  * already open). */
 349 VCSBase::VCSBaseEditorWidget *GitClient::createVCSEditor(const QString &id,
 350                                                          QString title,
 351                                                          // Source file or directory
 352                                                          const QString &source,
 353                                                          bool setSourceCodec,
 354                                                          // Dynamic property and value to identify that editor
 355                                                          const char *registerDynamicProperty,
 356                                                          const QString &dynamicPropertyValue,
 357                                                          QWidget *configWidget) const
 358 {
 359     VCSBase::VCSBaseEditorWidget *rc = 0;
 360     Q_ASSERT(!findExistingVCSEditor(registerDynamicProperty, dynamicPropertyValue));
 361
 362     // Create new, set wait message, set up with source and codec
 363     Core::IEditor *outputEditor = m_core->editorManager()->openEditorWithContents(id, &title, m_msgWait);
 364     outputEditor->file()->setProperty(registerDynamicProperty, dynamicPropertyValue);
 365     rc = VCSBase::VCSBaseEditorWidget::getVcsBaseEditor(outputEditor);
 366     connect(rc, SIGNAL(annotateRevisionRequested(QString,QString,int)),
 367             this, SLOT(slotBlameRevisionRequested(QString,QString,int)));
 368     QTC_ASSERT(rc, return 0);
 369     rc->setSource(source);
 370     if (setSourceCodec)
 371         rc->setCodec(VCSBase::VCSBaseEditorWidget::getCodec(source));
 372
 373     rc->setForceReadOnly(true);
 374     m_core->editorManager()->activateEditor(outputEditor, Core::EditorManager::ModeSwitch);
 375
 376     if (configWidget)
 377         rc->setConfigurationWidget(configWidget);
 378
 379     return rc;
 380 }
 381
 382 void GitClient::diff(const QString &workingDirectory,
 383                      const QStringList &diffArgs,
 384                      const QStringList &unstagedFileNames,
 385                      const QStringList &stagedFileNames)
 386 {
 387     const QString binary = settings()->stringValue(GitSettings::binaryPathKey);
 388     const QString editorId = QLatin1String(Git::Constants::GIT_DIFF_EDITOR_ID);
 389     const QString title = tr("Git Diff");
 390
 391     VCSBase::VCSBaseEditorWidget *editor = findExistingVCSEditor("originalFileName", workingDirectory);
 392     if (!editor) {
 393         GitCommitDiffArgumentsWidget *argWidget =
 394                 new GitCommitDiffArgumentsWidget(this, workingDirectory, diffArgs,
 395                                                  unstagedFileNames, stagedFileNames);
 396
 397         editor = createVCSEditor(editorId, title,
 398                                  workingDirectory, true, "originalFileName", workingDirectory, argWidget);
 399         connect(editor, SIGNAL(diffChunkReverted(VCSBase::DiffChunk)), argWidget, SLOT(executeCommand()));
 400         editor->setRevertDiffChunkEnabled(true);
 401     }
 402
 403     GitCommitDiffArgumentsWidget *argWidget = qobject_cast<GitCommitDiffArgumentsWidget *>(editor->configurationWidget());
 404     QStringList userDiffArgs = argWidget->arguments();
 405     editor->setDiffBaseDirectory(workingDirectory);
 406
 407     // Create a batch of 2 commands to be run after each other in case
 408     // we have a mixture of staged/unstaged files as is the case
 409     // when using the submit dialog.
 410     VCSBase::Command *command = createCommand(workingDirectory, editor);
 411     // Directory diff?
 412
 413     QStringList cmdArgs;
 414     cmdArgs << QLatin1String("diff") << QLatin1String(noColorOption);
 415
 416     int timeout = settings()->intValue(GitSettings::timeoutKey);
 417
 418     if (unstagedFileNames.empty() && stagedFileNames.empty()) {
 419        QStringList arguments(cmdArgs);
 420        arguments << userDiffArgs;
 421        outputWindow()->appendCommand(workingDirectory, binary, arguments);
 422        command->addJob(arguments, timeout);
 423     } else {
 424         // Files diff.
 425         if (!unstagedFileNames.empty()) {
 426            QStringList arguments(cmdArgs);
 427            arguments << userDiffArgs;
 428            arguments << QLatin1String("--") << unstagedFileNames;
 429            outputWindow()->appendCommand(workingDirectory, binary, arguments);
 430            command->addJob(arguments, timeout);
 431         }
 432         if (!stagedFileNames.empty()) {
 433            QStringList arguments(cmdArgs);
 434            arguments << userDiffArgs;
 435            arguments << QLatin1String("--cached") << diffArgs << QLatin1String("--") << stagedFileNames;
 436            outputWindow()->appendCommand(workingDirectory, binary, arguments);
 437            command->addJob(arguments, timeout);
 438         }
 439     }
 440     command->execute();
 441 }
 442
 443 void GitClient::diff(const QString &workingDirectory,
 444                      const QStringList &diffArgs,
 445                      const QString &fileName)
 446 {
 447     const QString editorId = QLatin1String(Git::Constants::GIT_DIFF_EDITOR_ID);
 448     const QString title = tr("Git Diff \"%1\"").arg(fileName);
 449     const QString sourceFile = VCSBase::VCSBaseEditorWidget::getSource(workingDirectory, fileName);
 450
 451     VCSBase::VCSBaseEditorWidget *editor = findExistingVCSEditor("originalFileName", sourceFile);
 452     if (!editor) {
 453         GitFileDiffArgumentsWidget *argWidget =
 454                 new GitFileDiffArgumentsWidget(this, workingDirectory, diffArgs, fileName);
 455
 456         editor = createVCSEditor(editorId, title, sourceFile, true, "originalFileName", sourceFile, argWidget);
 457         connect(editor, SIGNAL(diffChunkReverted(VCSBase::DiffChunk)), argWidget, SLOT(executeCommand()));
 458         editor->setRevertDiffChunkEnabled(true);
 459     }
 460
 461     GitFileDiffArgumentsWidget *argWidget = qobject_cast<GitFileDiffArgumentsWidget *>(editor->configurationWidget());
 462     QStringList userDiffArgs = argWidget->arguments();
 463
 464     QStringList cmdArgs;
 465     cmdArgs << QLatin1String("diff") << QLatin1String(noColorOption)
 466               << userDiffArgs;
 467
 468     if (!fileName.isEmpty())
 469         cmdArgs << QLatin1String("--") << fileName;
 470     executeGit(workingDirectory, cmdArgs, editor);
 471 }
 472
 473 void GitClient::diffBranch(const QString &workingDirectory,
 474                            const QStringList &diffArgs,
 475                            const QString &branchName)
 476 {
 477     const QString editorId = QLatin1String(Git::Constants::GIT_DIFF_EDITOR_ID);
 478     const QString title = tr("Git Diff Branch \"%1\"").arg(branchName);
 479     const QString sourceFile = VCSBase::VCSBaseEditorWidget::getSource(workingDirectory, QStringList());
 480
 481     VCSBase::VCSBaseEditorWidget *editor = findExistingVCSEditor("BranchName", branchName);
 482     if (!editor)
 483         editor = createVCSEditor(editorId, title, sourceFile, true, "BranchName", branchName,
 484                                  new GitBranchDiffArgumentsWidget(this, workingDirectory,
 485                                                                   diffArgs, branchName));
 486
 487     GitBranchDiffArgumentsWidget *argWidget = qobject_cast<GitBranchDiffArgumentsWidget *>(editor->configurationWidget());
 488     QStringList userDiffArgs = argWidget->arguments();
 489
 490     QStringList cmdArgs;
 491     cmdArgs << QLatin1String("diff") << QLatin1String(noColorOption)
 492               << userDiffArgs  << branchName;
 493
 494     executeGit(workingDirectory, cmdArgs, editor);
 495 }
 496
 497 void GitClient::status(const QString &workingDirectory)
 498 {
 499     // @TODO: Use "--no-color" once it is supported
 500     QStringList statusArgs(QLatin1String("status"));
 501     statusArgs << QLatin1String("-u");
 502     VCSBase::VCSBaseOutputWindow *outwin = outputWindow();
 503     outwin->setRepository(workingDirectory);
 504     VCSBase::Command *command = executeGit(workingDirectory, statusArgs, 0, true);
 505     connect(command, SIGNAL(finished(bool,int,QVariant)), outwin, SLOT(clearRepository()),
 506             Qt::QueuedConnection);
 507 }
 508
 509 static const char graphLogFormatC[] = "%h %d %an %s %ci";
 510
 511 // Create a graphical log.
 512 void GitClient::graphLog(const QString &workingDirectory, const QString & branch)
 513 {
 514     QStringList arguments;
 515     arguments << QLatin1String("log") << QLatin1String(noColorOption);
 516
 517     int logCount = settings()->intValue(GitSettings::logCountKey);
 518     if (logCount > 0)
 519          arguments << QLatin1String("-n") << QString::number(logCount);
 520     arguments << (QLatin1String("--pretty=format:") +  QLatin1String(graphLogFormatC))
 521               << QLatin1String("--topo-order") <<  QLatin1String("--graph");
 522
 523     QString title;
 524     if (branch.isEmpty()) {
 525         title = tr("Git Log");
 526     } else {
 527         title = tr("Git Log \"%1\"").arg(branch);
 528         arguments << branch;
 529     }
 530     const QString editorId = QLatin1String(Git::Constants::GIT_LOG_EDITOR_ID);
 531     const QString sourceFile = VCSBase::VCSBaseEditorWidget::getSource(workingDirectory, QStringList());
 532     VCSBase::VCSBaseEditorWidget *editor = findExistingVCSEditor("logFileName", sourceFile);
 533     if (!editor)
 534         editor = createVCSEditor(editorId, title, sourceFile, false, "logFileName", sourceFile, 0);
 535     executeGit(workingDirectory, arguments, editor);
 536 }
 537
 538 void GitClient::log(const QString &workingDirectory, const QStringList &fileNames,
 539                     bool enableAnnotationContextMenu)
 540 {
 541     QStringList arguments;
 542     arguments << QLatin1String("log") << QLatin1String(noColorOption)
 543               << QLatin1String(decorateOption);
 544
 545     int logCount = settings()->intValue(GitSettings::logCountKey);
 546     if (logCount > 0)
 547          arguments << QLatin1String("-n") << QString::number(logCount);
 548
 549     if (!fileNames.isEmpty())
 550         arguments.append(fileNames);
 551
 552     const QString msgArg = fileNames.empty() ? workingDirectory :
 553                            fileNames.join(QString(", "));
 554     const QString title = tr("Git Log \"%1\"").arg(msgArg);
 555     const QString editorId = QLatin1String(Git::Constants::GIT_LOG_EDITOR_ID);
 556     const QString sourceFile = VCSBase::VCSBaseEditorWidget::getSource(workingDirectory, fileNames);
 557     VCSBase::VCSBaseEditorWidget *editor = findExistingVCSEditor("logFileName", sourceFile);
 558     if (!editor)
 559         editor = createVCSEditor(editorId, title, sourceFile, false, "logFileName", sourceFile, 0);
 560     editor->setFileLogAnnotateEnabled(enableAnnotationContextMenu);
 561     executeGit(workingDirectory, arguments, editor);
 562 }
 563
 564 // Do not show "0000" or "^32ae4"
 565 static inline bool canShow(const QString &sha)
 566 {
 567     if (sha.startsWith(QLatin1Char('^')))
 568         return false;
 569     if (sha.count(QLatin1Char('0')) == sha.size())
 570         return false;
 571     return true;
 572 }
 573
 574 static inline QString msgCannotShow(const QString &sha)
 575 {
 576     return GitClient::tr("Cannot describe \"%1\".").arg(sha);
 577 }
 578
 579 void GitClient::show(const QString &source, const QString &id, const QStringList &args)
 580 {
 581     if (!canShow(id)) {
 582         outputWindow()->append(msgCannotShow(id));
 583         return;
 584     }
 585
 586     const QString title = tr("Git Show \"%1\"").arg(id);
 587     const QString editorId = QLatin1String(Git::Constants::GIT_DIFF_EDITOR_ID);
 588     VCSBase::VCSBaseEditorWidget *editor = findExistingVCSEditor("show", id);
 589     if (!editor)
 590         editor = createVCSEditor(editorId, title, source, true, "show", id,
 591                                  new GitShowArgumentsWidget(this, source, args, id));
 592
 593     GitShowArgumentsWidget *argWidget = qobject_cast<GitShowArgumentsWidget *>(editor->configurationWidget());
 594     QStringList userArgs = argWidget->arguments();
 595
 596     QStringList arguments;
 597     arguments << QLatin1String("show") << QLatin1String(noColorOption);
 598     arguments << QLatin1String(decorateOption);
 599     arguments.append(userArgs);
 600     arguments << id;
 601
 602     const QFileInfo sourceFi(source);
 603     const QString workDir = sourceFi.isDir() ? sourceFi.absoluteFilePath() : sourceFi.absolutePath();
 604     executeGit(workDir, arguments, editor);
 605 }
 606
 607 void GitClient::saveSettings()
 608 {
 609     settings()->writeSettings(m_core->settings());
 610 }
 611
 612 void GitClient::slotBlameRevisionRequested(const QString &source, QString change, int lineNumber)
 613 {
 614     // This might be invoked with a verbose revision description
 615     // "SHA1 author subject" from the annotation context menu. Strip the rest.
 616     const int blankPos = change.indexOf(QLatin1Char(' '));
 617     if (blankPos != -1)
 618         change.truncate(blankPos);
 619     const QFileInfo fi(source);
 620     blame(fi.absolutePath(), QStringList(), fi.fileName(), change, lineNumber);
 621 }
 622
 623 void GitClient::blame(const QString &workingDirectory,
 624                       const QStringList &args,
 625                       const QString &fileName,
 626                       const QString &revision,
 627                       int lineNumber)
 628 {
 629     const QString editorId = QLatin1String(Git::Constants::GIT_BLAME_EDITOR_ID);
 630     const QString id = VCSBase::VCSBaseEditorWidget::getTitleId(workingDirectory, QStringList(fileName), revision);
 631     const QString title = tr("Git Blame \"%1\"").arg(id);
 632     const QString sourceFile = VCSBase::VCSBaseEditorWidget::getSource(workingDirectory, fileName);
 633
 634     VCSBase::VCSBaseEditorWidget *editor = findExistingVCSEditor("blameFileName", id);
 635     if (!editor) {
 636         GitBlameArgumentsWidget *argWidget =
 637                 new GitBlameArgumentsWidget(this, workingDirectory, args,
 638                                             revision, fileName);
 639         editor = createVCSEditor(editorId, title, sourceFile, true, "blameFileName", id, argWidget);
 640         argWidget->setEditor(editor);
 641     }
 642
 643     GitBlameArgumentsWidget *argWidget = qobject_cast<GitBlameArgumentsWidget *>(editor->configurationWidget());
 644     QStringList userBlameArgs = argWidget->arguments();
 645
 646     QStringList arguments(QLatin1String("blame"));
 647     arguments << QLatin1String("--root");
 648     arguments.append(userBlameArgs);
 649     arguments << QLatin1String("--") << fileName;
 650     if (!revision.isEmpty())
 651         arguments << revision;
 652     executeGit(workingDirectory, arguments, editor, false, VCSBase::Command::NoReport, lineNumber);
 653 }
 654
 655 void GitClient::checkoutBranch(const QString &workingDirectory, const QString &branch)
 656 {
 657     QStringList arguments(QLatin1String("checkout"));
 658     arguments <<  branch;
 659     VCSBase::Command *cmd = executeGit(workingDirectory, arguments, 0, true);
 660     connectRepositoryChanged(workingDirectory, cmd);
 661 }
 662
 663 bool GitClient::synchronousCheckoutBranch(const QString &workingDirectory,
 664                                           const QString &branch,
 665                                           QString *errorMessage /* = 0 */)
 666 {
 667     QByteArray outputText;
 668     QByteArray errorText;
 669     QStringList arguments;
 670     arguments << QLatin1String("checkout") << branch;
 671     const bool rc = fullySynchronousGit(workingDirectory, arguments, &outputText, &errorText);
 672     const QString output = commandOutputFromLocal8Bit(outputText);
 673     outputWindow()->append(output);
 674     if (!rc) {
 675         const QString stdErr = commandOutputFromLocal8Bit(errorText);
 676         //: Meaning of the arguments: %1: Branch, %2: Repository, %3: Error message
 677         const QString msg = tr("Cannot checkout \"%1\" of \"%2\": %3").arg(branch, workingDirectory, stdErr);
 678         if (errorMessage) {
 679             *errorMessage = msg;
 680         } else {
 681             outputWindow()->appendError(msg);
 682         }
 683         return false;
 684     }
 685     return true;
 686 }
 687
 688 void GitClient::checkout(const QString &workingDirectory, const QString &fileName)
 689 {
 690     // Passing an empty argument as the file name is very dangereous, since this makes
 691     // git checkout apply to all files. Almost looks like a bug in git.
 692     if (fileName.isEmpty())
 693         return;
 694
 695     QStringList arguments;
 696     arguments << QLatin1String("checkout") << QLatin1String("HEAD") << QLatin1String("--")
 697             << fileName;
 698
 699     executeGit(workingDirectory, arguments, 0, true);
 700 }
 701
 702 void GitClient::hardReset(const QString &workingDirectory, const QString &commit)
 703 {
 704     QStringList arguments;
 705     arguments << QLatin1String("reset") << QLatin1String("--hard");
 706     if (!commit.isEmpty())
 707         arguments << commit;
 708
 709     VCSBase::Command *cmd = executeGit(workingDirectory, arguments, 0, true);
 710     connectRepositoryChanged(workingDirectory, cmd);
 711 }
 712
 713 void GitClient::addFile(const QString &workingDirectory, const QString &fileName)
 714 {
 715     QStringList arguments;
 716     arguments << QLatin1String("add") << fileName;
 717
 718     executeGit(workingDirectory, arguments, 0, true);
 719 }
 720
 721 // Warning: 'intendToAdd' works only from 1.6.1 onwards
 722 bool GitClient::synchronousAdd(const QString &workingDirectory,
 723                                bool intendToAdd,
 724                                const QStringList &files)
 725 {
 726     QByteArray outputText;
 727     QByteArray errorText;
 728     QStringList arguments;
 729     arguments << QLatin1String("add");
 730     if (intendToAdd)
 731         arguments << QLatin1String("--intent-to-add");
 732     arguments.append(files);
 733     const bool rc = fullySynchronousGit(workingDirectory, arguments, &outputText, &errorText);
 734     if (!rc) {
 735         const QString errorMessage = tr("Cannot add %n file(s) to \"%1\": %2", 0, files.size()).
 736                                      arg(QDir::toNativeSeparators(workingDirectory),
 737                                      commandOutputFromLocal8Bit(errorText));
 738         outputWindow()->appendError(errorMessage);
 739     }
 740     return rc;
 741 }
 742
 743 bool GitClient::synchronousDelete(const QString &workingDirectory,
 744                                   bool force,
 745                                   const QStringList &files)
 746 {
 747     QByteArray outputText;
 748     QByteArray errorText;
 749     QStringList arguments;
 750     arguments << QLatin1String("rm");
 751     if (force)
 752         arguments << QLatin1String("--force");
 753     arguments.append(files);
 754     const bool rc = fullySynchronousGit(workingDirectory, arguments, &outputText, &errorText);
 755     if (!rc) {
 756         const QString errorMessage = tr("Cannot remove %n file(s) from \"%1\": %2", 0, files.size()).
 757                                      arg(QDir::toNativeSeparators(workingDirectory), commandOutputFromLocal8Bit(errorText));
 758         outputWindow()->appendError(errorMessage);
 759     }
 760     return rc;
 761 }
 762
 763 bool GitClient::synchronousMove(const QString &workingDirectory,
 764                                 const QString &from,
 765                                 const QString &to)
 766 {
 767     QByteArray outputText;
 768     QByteArray errorText;
 769     QStringList arguments;
 770     arguments << QLatin1String("mv");
 771     arguments << (from);
 772     arguments << (to);
 773     const bool rc = fullySynchronousGit(workingDirectory, arguments, &outputText, &errorText);
 774     if (!rc) {
 775         const QString errorMessage = tr("Cannot move from \"%1\" to \"%2\": %3").
 776                                      arg(from, to, commandOutputFromLocal8Bit(errorText));
 777         outputWindow()->appendError(errorMessage);
 778     }
 779     return rc;
 780 }
 781
 782 bool GitClient::synchronousReset(const QString &workingDirectory,
 783                                  const QStringList &files,
 784                                  QString *errorMessage)
 785 {
 786     QByteArray outputText;
 787     QByteArray errorText;
 788     QStringList arguments;
 789     arguments << QLatin1String("reset");
 790     if (files.isEmpty())
 791         arguments << QLatin1String("--hard");
 792     else
 793         arguments << QLatin1String("HEAD") << QLatin1String("--") << files;
 794     const bool rc = fullySynchronousGit(workingDirectory, arguments, &outputText, &errorText);
 795     const QString output = commandOutputFromLocal8Bit(outputText);
 796     outputWindow()->append(output);
 797     // Note that git exits with 1 even if the operation is successful
 798     // Assume real failure if the output does not contain "foo.cpp modified"
 799     // or "Unstaged changes after reset" (git 1.7.0).
 800     if (!rc && (!output.contains(QLatin1String("modified"))
 801          && !output.contains(QLatin1String("Unstaged changes after reset")))) {
 802         const QString stdErr = commandOutputFromLocal8Bit(errorText);
 803         const QString msg = files.isEmpty() ?
 804                             tr("Cannot reset \"%1\": %2").arg(QDir::toNativeSeparators(workingDirectory), stdErr) :
 805                             tr("Cannot reset %n file(s) in \"%1\": %2", 0, files.size()).
 806                             arg(QDir::toNativeSeparators(workingDirectory), stdErr);
 807         if (errorMessage) {
 808             *errorMessage = msg;
 809         } else {
 810             outputWindow()->appendError(msg);
 811         }
 812         return false;
 813     }
 814     return true;
 815 }
 816
 817 // Initialize repository
 818 bool GitClient::synchronousInit(const QString &workingDirectory)
 819 {
 820     QByteArray outputText;
 821     QByteArray errorText;
 822     const QStringList arguments(QLatin1String("init"));
 823     const bool rc = fullySynchronousGit(workingDirectory, arguments, &outputText, &errorText);
 824     // '[Re]Initialized...'
 825     outputWindow()->append(commandOutputFromLocal8Bit(outputText));
 826     if (!rc)
 827         outputWindow()->appendError(commandOutputFromLocal8Bit(errorText));
 828     else {
 829         // TODO: Turn this into a VCSBaseClient and use resetCachedVcsInfo(...)
 830         Core::VcsManager *vcsManager = m_core->vcsManager();
 831         vcsManager->resetVersionControlForDirectory(workingDirectory);
 832     }
 833     return rc;
 834 }
 835
 836 /* Checkout, supports:
 837  * git checkout -- <files>
 838  * git checkout revision -- <files>
 839  * git checkout revision -- . */
 840 bool GitClient::synchronousCheckoutFiles(const QString &workingDirectory,
 841                                          QStringList files /* = QStringList() */,
 842                                          QString revision /* = QString() */,
 843                                          QString *errorMessage /* = 0 */,
 844                                          bool revertStaging /* = true */)
 845 {
 846     if (revertStaging && revision.isEmpty())
 847         revision = QLatin1String("HEAD");
 848     if (files.isEmpty())
 849         files = QStringList(QString(QLatin1Char('.')));
 850     QByteArray outputText;
 851     QByteArray errorText;
 852     QStringList arguments;
 853     arguments << QLatin1String("checkout");
 854     if (revertStaging)
 855         arguments << revision;
 856     arguments << QLatin1String("--") << files;
 857     const bool rc = fullySynchronousGit(workingDirectory, arguments, &outputText, &errorText);
 858     if (!rc) {
 859         const QString fileArg = files.join(QLatin1String(", "));
 860         //: Meaning of the arguments: %1: revision, %2: files, %3: repository,
 861         //: %4: Error message
 862         const QString msg = tr("Cannot checkout \"%1\" of %2 in \"%3\": %4").
 863                             arg(revision, fileArg, workingDirectory, commandOutputFromLocal8Bit(errorText));
 864         if (errorMessage) {
 865             *errorMessage = msg;
 866         } else {
 867             outputWindow()->appendError(msg);
 868         }
 869         return false;
 870     }
 871     return true;
 872 }
 873
 874 static inline QString msgParentRevisionFailed(const QString &workingDirectory,
 875                                               const QString &revision,
 876                                               const QString &why)
 877 {
 878     //: Failed to find parent revisions of a SHA1 for "annotate previous"
 879     return GitClient::tr("Cannot find parent revisions of \"%1\" in \"%2\": %3").arg(revision, workingDirectory, why);
 880 }
 881
 882 static inline QString msgInvalidRevision()
 883 {
 884     return GitClient::tr("Invalid revision");
 885 }
 886
 887 // Split a line of "<commit> <parent1> ..." to obtain parents from "rev-list" or "log".
 888 static inline bool splitCommitParents(const QString &line,
 889                                       QString *commit = 0,
 890                                       QStringList *parents = 0)
 891 {
 892     if (commit)
 893         commit->clear();
 894     if (parents)
 895         parents->clear();
 896     QStringList tokens = line.trimmed().split(QLatin1Char(' '));
 897     if (tokens.size() < 2)
 898         return false;
 899     if (commit)
 900         *commit = tokens.front();
 901     tokens.pop_front();
 902     if (parents)
 903         *parents = tokens;
 904     return true;
 905 }
 906
 907 // Find out the immediate parent revisions of a revision of the repository.
 908 // Might be several in case of merges.
 909 bool GitClient::synchronousParentRevisions(const QString &workingDirectory,
 910                                            const QStringList &files /* = QStringList() */,
 911                                            const QString &revision,
 912                                            QStringList *parents,
 913                                            QString *errorMessage)
 914 {
 915     QByteArray outputTextData;
 916     QByteArray errorText;
 917     QStringList arguments;
 918     arguments << QLatin1String("rev-list") << QLatin1String(GitClient::noColorOption)
 919               << QLatin1String("--parents") << QLatin1String("--max-count=1") << revision;
 920     if (!files.isEmpty()) {
 921         arguments.append(QLatin1String("--"));
 922         arguments.append(files);
 923     }
 924     const bool rc = fullySynchronousGit(workingDirectory, arguments, &outputTextData, &errorText);
 925     if (!rc) {
 926         *errorMessage = msgParentRevisionFailed(workingDirectory, revision, commandOutputFromLocal8Bit(errorText));
 927         return false;
 928     }
 929     // Should result in one line of blank-delimited revisions, specifying current first
 930     // unless it is top.
 931     QString outputText = commandOutputFromLocal8Bit(outputTextData);
 932     outputText.remove(QLatin1Char('\n'));
 933     if (!splitCommitParents(outputText, 0, parents)) {
 934         *errorMessage = msgParentRevisionFailed(workingDirectory, revision, msgInvalidRevision());
 935         return false;
 936     }
 937     return true;
 938 }
 939
 940 // Short SHA1, author, subject
 941 static const char defaultShortLogFormatC[] = "%h (%an \"%s\")";
 942
 943 bool GitClient::synchronousShortDescription(const QString &workingDirectory, const QString &revision,
 944                                             QString *description, QString *errorMessage)
 945 {
 946     // Short SHA 1, author, subject
 947     return synchronousShortDescription(workingDirectory, revision,
 948                                        QLatin1String(defaultShortLogFormatC),
 949                                        description, errorMessage);
 950 }
 951
 952 // Convenience working on a list of revisions
 953 bool GitClient::synchronousShortDescriptions(const QString &workingDirectory, const QStringList &revisions,
 954                                              QStringList *descriptions, QString *errorMessage)
 955 {
 956     descriptions->clear();
 957     foreach (const QString &revision, revisions) {
 958         QString description;
 959         if (!synchronousShortDescription(workingDirectory, revision, &description, errorMessage)) {
 960             descriptions->clear();
 961             return false;
 962         }
 963         descriptions->push_back(description);
 964     }
 965     return true;
 966 }
 967
 968 static inline QString msgCannotDetermineBranch(const QString &workingDirectory, const QString &why)
 969 {
 970     return GitClient::tr("Cannot retrieve branch of \"%1\": %2").arg(QDir::toNativeSeparators(workingDirectory), why);
 971 }
 972
 973 // Retrieve head revision/branch
 974 bool GitClient::synchronousTopRevision(const QString &workingDirectory, QString *revision,
 975                                        QString *branch, QString *errorMessageIn)
 976 {
 977     QByteArray outputTextData;
 978     QByteArray errorText;
 979     QStringList arguments;
 980     QString errorMessage;
 981     do {
 982         // get revision
 983         if (revision) {
 984             revision->clear();
 985             arguments << QLatin1String("log") << QLatin1String(noColorOption)
 986                     <<  QLatin1String("--max-count=1") << QLatin1String("--pretty=format:%H");
 987             if (!fullySynchronousGit(workingDirectory, arguments, &outputTextData, &errorText)) {
 988                 errorMessage = tr("Cannot retrieve top revision of \"%1\": %2").arg(QDir::toNativeSeparators(workingDirectory), commandOutputFromLocal8Bit(errorText));
 989                 break;
 990             }
 991             *revision = commandOutputFromLocal8Bit(outputTextData);
 992             revision->remove(QLatin1Char('\n'));
 993         } // revision desired
 994         // get branch
 995         if (branch) {
 996             branch->clear();
 997             arguments.clear();
 998             arguments << QLatin1String("branch") << QLatin1String(noColorOption);
 999             if (!fullySynchronousGit(workingDirectory, arguments, &outputTextData, &errorText)) {
1000                 errorMessage = msgCannotDetermineBranch(workingDirectory, commandOutputFromLocal8Bit(errorText));
1001                 break;
1002             }
1003             /* parse output for current branch: \code
1004 * master
1005   branch2
1006 \endcode */
1007             const QString branchPrefix = QLatin1String("* ");
1008             foreach(const QString &line, commandOutputLinesFromLocal8Bit(outputTextData)) {
1009                 if (line.startsWith(branchPrefix)) {
1010                     *branch = line;
1011                     branch->remove(0, branchPrefix.size());
1012                     break;
1013                 }
1014             }
1015             if (branch->isEmpty()) {
1016                 errorMessage = msgCannotDetermineBranch(workingDirectory,
1017                                                         QString::fromLatin1("Internal error: Failed to parse output: %1").arg(commandOutputFromLocal8Bit(outputTextData)));
1018                 break;
1019             }
1020         } // branch
1021     } while (false);
1022     const bool failed = (revision && revision->isEmpty()) || (branch && branch->isEmpty());
1023     if (failed && !errorMessage.isEmpty()) {
1024         if (errorMessageIn) {
1025             *errorMessageIn = errorMessage;
1026         } else {
1027             outputWindow()->appendError(errorMessage);
1028         }
1029     }
1030     return !failed;
1031 }
1032
1033 // Format an entry in a one-liner for selection list using git log.
1034 bool GitClient::synchronousShortDescription(const QString &workingDirectory, const QString &revision,
1035                                             const QString &format, QString *description,
1036                                             QString *errorMessage)
1037 {
1038     QByteArray outputTextData;
1039     QByteArray errorText;
1040     QStringList arguments;
1041     arguments << QLatin1String("log") << QLatin1String(GitClient::noColorOption)
1042               << (QLatin1String("--pretty=format:") + format)
1043               << QLatin1String("--max-count=1") << revision;
1044     const bool rc = fullySynchronousGit(workingDirectory, arguments, &outputTextData, &errorText);
1045     if (!rc) {
1046         *errorMessage = tr("Cannot describe revision \"%1\" in \"%2\": %3").arg(revision, workingDirectory, commandOutputFromLocal8Bit(errorText));
1047         return false;
1048     }
1049     *description = commandOutputFromLocal8Bit(outputTextData);
1050     if (description->endsWith(QLatin1Char('\n')))
1051         description->truncate(description->size() - 1);
1052     return true;
1053 }
1054
1055 // Create a default message to be used for describing stashes
1056 static inline QString creatorStashMessage(const QString &keyword = QString())
1057 {
1058     QString rc = QCoreApplication::applicationName();
1059     rc += QLatin1Char(' ');
1060     if (!keyword.isEmpty()) {
1061         rc += keyword;
1062         rc += QLatin1Char(' ');
1063     }
1064     rc += QDateTime::currentDateTime().toString(Qt::ISODate);
1065     return rc;
1066 }
1067
1068 /* Do a stash and return the message as identifier. Note that stash names (stash{n})
1069  * shift as they are pushed, so, enforce the use of messages to identify them. Flags:
1070  * StashPromptDescription: Prompt the user for a description message.
1071  * StashImmediateRestore: Immediately re-apply this stash (used for snapshots), user keeps on working
1072  * StashIgnoreUnchanged: Be quiet about unchanged repositories (used for IVersionControl's snapshots). */
1073
1074 QString GitClient::synchronousStash(const QString &workingDirectory, const QString &messageKeyword,
1075                                     unsigned flags, bool *unchanged)
1076 {
1077     if (unchanged)
1078         *unchanged = false;
1079     QString message;
1080     bool success = false;
1081     // Check for changes and stash
1082     QString errorMessage;
1083     switch (gitStatus(workingDirectory, false, 0, &errorMessage)) {
1084     case  StatusChanged: {
1085             message = creatorStashMessage(messageKeyword);
1086             do {
1087                 if ((flags & StashPromptDescription)) {
1088                     if (!inputText(Core::ICore::instance()->mainWindow(),
1089                                    tr("Stash Description"), tr("Description:"), &message))
1090                         break;
1091                 }
1092                 if (!executeSynchronousStash(workingDirectory, message))
1093                     break;
1094                 if ((flags & StashImmediateRestore)
1095                     && !synchronousStashRestore(workingDirectory, QLatin1String("stash@{0}")))
1096                     break;
1097                 success = true;
1098             } while (false);
1099         }
1100         break;
1101     case StatusUnchanged:
1102         if (unchanged)
1103             *unchanged = true;
1104         if (!(flags & StashIgnoreUnchanged))
1105             outputWindow()->append(msgNoChangedFiles());
1106         break;
1107     case StatusFailed:
1108         outputWindow()->append(errorMessage);
1109         break;
1110     }
1111     if (!success)
1112         message.clear();
1113     return message;
1114 }
1115
1116 bool GitClient::executeSynchronousStash(const QString &workingDirectory,
1117                                         const QString &message,
1118                                         QString *errorMessage)
1119 {
1120     QByteArray outputText;
1121     QByteArray errorText;
1122     QStringList arguments;
1123     arguments << QLatin1String("stash");
1124     if (!message.isEmpty())
1125         arguments << QLatin1String("save") << message;
1126     const bool rc = fullySynchronousGit(workingDirectory, arguments, &outputText, &errorText);
1127     if (!rc) {
1128         const QString msg = tr("Cannot stash in \"%1\": %2").
1129                             arg(QDir::toNativeSeparators(workingDirectory),
1130                                 commandOutputFromLocal8Bit(errorText));
1131         if (errorMessage) {
1132             *errorMessage = msg;
1133         } else {
1134             outputWindow()->append(msg);
1135         }
1136         return false;
1137     }
1138     return true;
1139 }
1140
1141 // Resolve a stash name from message
1142 bool GitClient::stashNameFromMessage(const QString &workingDirectory,
1143                                      const QString &message, QString *name,
1144                                      QString *errorMessage)
1145 {
1146     // All happy
1147     if (message.startsWith(QLatin1String(stashNamePrefix))) {
1148         *name = message;
1149         return true;
1150     }
1151     // Retrieve list and find via message
1152     QList<Stash> stashes;
1153     if (!synchronousStashList(workingDirectory, &stashes, errorMessage))
1154         return false;
1155     foreach (const Stash &s, stashes) {
1156         if (s.message == message) {
1157             *name = s.name;
1158             return true;
1159         }
1160     }
1161     //: Look-up of a stash via its descriptive message failed.
1162     const QString msg = tr("Cannot resolve stash message \"%1\" in \"%2\".").arg(message, workingDirectory);
1163     if (errorMessage) {
1164         *errorMessage = msg;
1165     } else {
1166         outputWindow()->append(msg);
1167     }
1168     return  false;
1169 }
1170
1171 bool GitClient::synchronousBranchCmd(const QString &workingDirectory, QStringList branchArgs,
1172                                      QString *output, QString *errorMessage)
1173 {
1174     branchArgs.push_front(QLatin1String("branch"));
1175     QByteArray outputText;
1176     QByteArray errorText;
1177     const bool rc = fullySynchronousGit(workingDirectory, branchArgs, &outputText, &errorText);
1178     if (!rc) {
1179         *errorMessage = tr("Cannot run \"git branch\" in \"%1\": %2").arg(QDir::toNativeSeparators(workingDirectory), commandOutputFromLocal8Bit(errorText));
1180         return false;
1181     }
1182     *output = commandOutputFromLocal8Bit(outputText);
1183     return true;
1184 }
1185
1186 bool GitClient::synchronousRemoteCmd(const QString &workingDirectory, QStringList remoteArgs,
1187                                      QString *output, QString *errorMessage)
1188 {
1189     remoteArgs.push_front(QLatin1String("remote"));
1190     QByteArray outputText;
1191     QByteArray errorText;
1192     const bool rc = fullySynchronousGit(workingDirectory, remoteArgs, &outputText, &errorText);
1193     if (!rc) {
1194         *errorMessage = tr("Cannot run \"git remote\" in \"%1\": %2").arg(QDir::toNativeSeparators(workingDirectory), commandOutputFromLocal8Bit(errorText));
1195         return false;
1196     }
1197     *output = commandOutputFromLocal8Bit(outputText);
1198     return true;
1199 }
1200
1201 bool GitClient::synchronousShow(const QString &workingDirectory, const QString &id,
1202                                  QString *output, QString *errorMessage)
1203 {
1204     if (!canShow(id)) {
1205         *errorMessage = msgCannotShow(id);
1206         return false;
1207     }
1208     QStringList args(QLatin1String("show"));
1209     args << QLatin1String(decorateOption) << QLatin1String(noColorOption) << id;
1210     QByteArray outputText;
1211     QByteArray errorText;
1212     const bool rc = fullySynchronousGit(workingDirectory, args, &outputText, &errorText);
1213     if (!rc) {
1214         *errorMessage = tr("Cannot run \"git show\" in \"%1\": %2").arg(QDir::toNativeSeparators(workingDirectory), commandOutputFromLocal8Bit(errorText));
1215         return false;
1216     }
1217     *output = commandOutputFromLocal8Bit(outputText);
1218     return true;
1219 }
1220
1221 // Retrieve list of files to be cleaned
1222 bool GitClient::synchronousCleanList(const QString &workingDirectory,
1223                                      QStringList *files, QString *errorMessage)
1224 {
1225     files->clear();
1226     QStringList args;
1227     args << QLatin1String("clean") << QLatin1String("--dry-run") << QLatin1String("-dxf");
1228     QByteArray outputText;
1229     QByteArray errorText;
1230     const bool rc = fullySynchronousGit(workingDirectory, args, &outputText, &errorText);
1231     if (!rc) {
1232         *errorMessage = tr("Cannot run \"git clean\" in \"%1\": %2").arg(QDir::toNativeSeparators(workingDirectory), commandOutputFromLocal8Bit(errorText));
1233         return false;
1234     }
1235     // Filter files that git would remove
1236     const QString prefix = QLatin1String("Would remove ");
1237     foreach(const QString &line, commandOutputLinesFromLocal8Bit(outputText))
1238         if (line.startsWith(prefix))
1239             files->push_back(line.mid(prefix.size()));
1240     return true;
1241 }
1242
1243 bool GitClient::synchronousApplyPatch(const QString &workingDirectory,
1244                                       const QString &file, QString *errorMessage)
1245 {
1246     QStringList args;
1247     args << QLatin1String("apply") << QLatin1String("--whitespace=fix") << file;
1248     QByteArray outputText;
1249     QByteArray errorText;
1250     const bool rc = fullySynchronousGit(workingDirectory, args, &outputText, &errorText);
1251     if (rc) {
1252         if (!errorText.isEmpty())
1253             *errorMessage = tr("There were warnings while applying \"%1\" to \"%2\":\n%3").arg(file, workingDirectory, commandOutputFromLocal8Bit(errorText));
1254     } else {
1255         *errorMessage = tr("Cannot apply patch \"%1\" to \"%2\": %3").arg(file, workingDirectory, commandOutputFromLocal8Bit(errorText));
1256         return false;
1257     }
1258     return true;
1259 }
1260
1261 // Factory function to create an asynchronous command
1262 VCSBase::Command *GitClient::createCommand(const QString &workingDirectory,
1263                                            VCSBase::VCSBaseEditorWidget* editor,
1264                                            bool useOutputToWindow,
1265                                            int editorLineNumber)
1266 {
1267     VCSBase::Command *command = new VCSBase::Command(gitBinaryPath(), workingDirectory, processEnvironment());
1268     command->setCookie(QVariant(editorLineNumber));
1269     if (editor)
1270         connect(command, SIGNAL(finished(bool,int,QVariant)), editor, SLOT(commandFinishedGotoLine(bool,int,QVariant)));
1271     if (useOutputToWindow) {
1272         if (editor) // assume that the commands output is the important thing
1273             connect(command, SIGNAL(outputData(QByteArray)), outputWindow(), SLOT(appendDataSilently(QByteArray)));
1274         else
1275             connect(command, SIGNAL(outputData(QByteArray)), outputWindow(), SLOT(appendData(QByteArray)));
1276     } else {
1277         if (editor)
1278             connect(command, SIGNAL(outputData(QByteArray)), editor, SLOT(setPlainTextDataFiltered(QByteArray)));
1279     }
1280
1281     if (outputWindow())
1282         connect(command, SIGNAL(errorText(QString)), outputWindow(), SLOT(appendError(QString)));
1283     return command;
1284 }
1285
1286 // Execute a single command
1287 VCSBase::Command *GitClient::executeGit(const QString &workingDirectory,
1288                                         const QStringList &arguments,
1289                                         VCSBase::VCSBaseEditorWidget* editor,
1290                                         bool useOutputToWindow,
1291                                         VCSBase::Command::TerminationReportMode tm,
1292                                         int editorLineNumber,
1293                                         bool unixTerminalDisabled)
1294 {
1295     outputWindow()->appendCommand(workingDirectory, settings()->stringValue(GitSettings::binaryPathKey), arguments);
1296     VCSBase::Command *command = createCommand(workingDirectory, editor, useOutputToWindow, editorLineNumber);
1297     command->addJob(arguments, settings()->intValue(GitSettings::timeoutKey));
1298     command->setTerminationReportMode(tm);
1299     command->setUnixTerminalDisabled(unixTerminalDisabled);
1300     command->execute();
1301     return command;
1302 }
1303
1304 QProcessEnvironment GitClient::processEnvironment() const
1305 {
1306
1307     QProcessEnvironment environment = QProcessEnvironment::systemEnvironment();
1308     if (settings()->boolValue(GitSettings::adoptPathKey))
1309         environment.insert(QLatin1String("PATH"), settings()->stringValue(GitSettings::pathKey));
1310 #ifdef Q_OS_WIN
1311     if (settings()->boolValue(GitSettings::winSetHomeEnvironmentKey))
1312         environment.insert(QLatin1String("HOME"), QDir::toNativeSeparators(QDir::homePath()));
1313 #endif // Q_OS_WIN
1314     // Set up SSH and C locale (required by git using perl).
1315     VCSBase::VCSBasePlugin::setProcessEnvironment(&environment, false);
1316     return environment;
1317 }
1318
1319 // Synchronous git execution using Utils::SynchronousProcess, with
1320 // log windows updating.
1321 Utils::SynchronousProcessResponse GitClient::synchronousGit(const QString &workingDirectory,
1322                                                             const QStringList &gitArguments,
1323                                                             unsigned flags,
1324                                                             QTextCodec *stdOutCodec)
1325 {
1326     return VCSBase::VCSBasePlugin::runVCS(workingDirectory, gitBinaryPath(), gitArguments,
1327                                           settings()->intValue(GitSettings::timeoutKey) * 1000,
1328                                           processEnvironment(),
1329                                           flags, stdOutCodec);
1330 }
1331
1332 bool GitClient::fullySynchronousGit(const QString &workingDirectory,
1333                                     const QStringList &gitArguments,
1334                                     QByteArray* outputText,
1335                                     QByteArray* errorText,
1336                                     bool logCommandToWindow) const
1337 {
1338     return VCSBase::VCSBasePlugin::runFullySynchronous(workingDirectory, gitBinaryPath(), gitArguments,
1339                                                        processEnvironment(), outputText, errorText,
1340                                                        settings()->intValue(GitSettings::timeoutKey) * 1000,
1341                                                        logCommandToWindow);
1342 }
1343
1344 static inline int askWithDetailedText(QWidget *parent,
1345                                       const QString &title, const QString &msg,
1346                                       const QString &inf,
1347                                       QMessageBox::StandardButton defaultButton,
1348                                       QMessageBox::StandardButtons buttons = QMessageBox::Yes|QMessageBox::No)
1349 {
1350     QMessageBox msgBox(QMessageBox::Question, title, msg, buttons, parent);
1351     msgBox.setDetailedText(inf);
1352     msgBox.setDefaultButton(defaultButton);
1353     return msgBox.exec();
1354 }
1355
1356 // Convenience that pops up an msg box.
1357 GitClient::StashResult GitClient::ensureStash(const QString &workingDirectory)
1358 {
1359     QString errorMessage;
1360     const StashResult sr = ensureStash(workingDirectory, &errorMessage);
1361     if (sr == StashFailed)
1362         outputWindow()->appendError(errorMessage);
1363     return sr;
1364 }
1365
1366 // Ensure that changed files are stashed before a pull or similar
1367 GitClient::StashResult GitClient::ensureStash(const QString &workingDirectory, QString *errorMessage)
1368 {
1369     QString statusOutput;
1370     switch (gitStatus(workingDirectory, false, &statusOutput, errorMessage)) {
1371         case StatusChanged:
1372         break;
1373         case StatusUnchanged:
1374         return StashUnchanged;
1375         case StatusFailed:
1376         return StashFailed;
1377     }
1378
1379     const int answer = askWithDetailedText(m_core->mainWindow(), tr("Changes"),
1380                              tr("Would you like to stash your changes?"),
1381                              statusOutput, QMessageBox::Yes, QMessageBox::Yes|QMessageBox::No|QMessageBox::Cancel);
1382     switch (answer) {
1383         case QMessageBox::Cancel:
1384             return StashCanceled;
1385         case QMessageBox::Yes:
1386             if (!executeSynchronousStash(workingDirectory, creatorStashMessage(QLatin1String("push")), errorMessage))
1387                 return StashFailed;
1388             break;
1389         case QMessageBox::No: // At your own risk, so.
1390             return NotStashed;
1391         }
1392
1393     return Stashed;
1394  }
1395
1396 // Trim a git status file spec: "modified:    foo .cpp" -> "modified: foo .cpp"
1397 static inline QString trimFileSpecification(QString fileSpec)
1398 {
1399     const int colonIndex = fileSpec.indexOf(QLatin1Char(':'));
1400     if (colonIndex != -1) {
1401         // Collapse the sequence of spaces
1402         const int filePos = colonIndex + 2;
1403         int nonBlankPos = filePos;
1404         for ( ; fileSpec.at(nonBlankPos).isSpace(); nonBlankPos++) ;
1405         if (nonBlankPos > filePos)
1406             fileSpec.remove(filePos, nonBlankPos - filePos);
1407     }
1408     return fileSpec;
1409 }
1410
1411 GitClient::StatusResult GitClient::gitStatus(const QString &workingDirectory,
1412                                              bool untracked,
1413                                              QString *output,
1414                                              QString *errorMessage,
1415                                              bool *onBranch)
1416 {
1417     // Run 'status'. Note that git returns exitcode 1 if there are no added files.
1418     QByteArray outputText;
1419     QByteArray errorText;
1420     // @TODO: Use "--no-color" once it is supported
1421     QStringList statusArgs(QLatin1String("status"));
1422     if (untracked)
1423         statusArgs << QLatin1String("-u");
1424     const bool statusRc = fullySynchronousGit(workingDirectory, statusArgs, &outputText, &errorText);
1425     VCSBase::Command::removeColorCodes(&outputText);
1426     if (output)
1427         *output = commandOutputFromLocal8Bit(outputText);
1428     const bool branchKnown = outputText.contains(kBranchIndicatorC);
1429     if (onBranch)
1430         *onBranch = branchKnown;
1431     // Is it something really fatal?
1432     if (!statusRc && !branchKnown && !outputText.contains("# Not currently on any branch.")) {
1433         if (errorMessage) {
1434             const QString error = commandOutputFromLocal8Bit(errorText);
1435             *errorMessage = tr("Cannot obtain status: %1").arg(error);
1436         }
1437         return StatusFailed;
1438     }
1439     // Unchanged (output text depending on whether -u was passed)
1440     if (outputText.contains("nothing to commit"))
1441         return StatusUnchanged;
1442     if (outputText.contains("nothing added to commit but untracked files present"))
1443         return untracked ? StatusChanged : StatusUnchanged;
1444     return StatusChanged;
1445 }
1446
1447 // Quietly retrieve branch list of remote repository URL
1448 //
1449 // The branch HEAD is pointing to is always returned first.
1450 QStringList GitClient::synchronousRepositoryBranches(const QString &repositoryURL)
1451 {
1452     QStringList arguments(QLatin1String("ls-remote"));
1453     arguments << repositoryURL << QLatin1String("HEAD") << QLatin1String("refs/heads/*");
1454     const unsigned flags =
1455             VCSBase::VCSBasePlugin::SshPasswordPrompt|
1456             VCSBase::VCSBasePlugin::SuppressStdErrInLogWindow|
1457             VCSBase::VCSBasePlugin::SuppressFailMessageInLogWindow;
1458     const Utils::SynchronousProcessResponse resp = synchronousGit(QString(), arguments, flags);
1459     QStringList branches;
1460     branches << "<detached HEAD>";
1461     QString headSha;
1462     if (resp.result == Utils::SynchronousProcessResponse::Finished) {
1463         // split "82bfad2f51d34e98b18982211c82220b8db049b<tab>refs/heads/master"
1464         foreach(const QString &line, resp.stdOut.split(QLatin1Char('\n'))) {
1465             if (line.endsWith("\tHEAD")) {
1466                 Q_ASSERT(headSha.isNull());
1467                 headSha = line.left(line.indexOf(QChar('\t')));
1468                 continue;
1469             }
1470
1471             const int slashPos = line.lastIndexOf(QLatin1Char('/'));
1472             const QString branchName = line.mid(slashPos + 1);
1473             if (slashPos != -1) {
1474                 if (line.startsWith(headSha))
1475                     branches[0] = branchName;
1476                 else
1477                     branches.push_back(branchName);
1478             }
1479         }
1480     }
1481     return branches;
1482 }
1483
1484 void GitClient::launchGitK(const QString &workingDirectory)
1485 {
1486     const QFileInfo binaryInfo(gitBinaryPath());
1487     QDir foundBinDir(binaryInfo.dir());
1488     const bool foundBinDirIsCmdDir = foundBinDir.dirName() == "cmd";
1489     QProcessEnvironment env = processEnvironment();
1490     if (tryLauchingGitK(env, workingDirectory, foundBinDir.path(), foundBinDirIsCmdDir))
1491         return;
1492     if (!foundBinDirIsCmdDir)
1493         return;
1494     foundBinDir.cdUp();
1495     tryLauchingGitK(env, workingDirectory, foundBinDir.path() + "/bin", false);
1496 }
1497
1498 bool GitClient::tryLauchingGitK(const QProcessEnvironment &env,
1499                                 const QString &workingDirectory,
1500                                 const QString &gitBinDirectory,
1501                                 bool silent)
1502 {
1503 #ifdef Q_OS_WIN
1504     // Launch 'wish' shell from git binary directory with the gitk located there
1505     const QString binary = gitBinDirectory + QLatin1String("/wish");
1506     QStringList arguments(gitBinDirectory + QLatin1String("/gitk"));
1507 #else
1508     // Simple: Run gitk from binary path
1509     const QString binary = gitBinDirectory + QLatin1String("/gitk");
1510     QStringList arguments;
1511 #endif
1512     VCSBase::VCSBaseOutputWindow *outwin = VCSBase::VCSBaseOutputWindow::instance();
1513     const QString gitkOpts = settings()->stringValue(GitSettings::gitkOptionsKey);
1514     if (!gitkOpts.isEmpty())
1515         arguments.append(Utils::QtcProcess::splitArgs(gitkOpts));
1516     outwin->appendCommand(workingDirectory, binary, arguments);
1517     // This should always use QProcess::startDetached (as not to kill
1518     // the child), but that does not have an environment parameter.
1519     bool success = false;
1520     if (settings()->boolValue(GitSettings::adoptPathKey)) {
1521         QProcess *process = new QProcess(this);
1522         process->setWorkingDirectory(workingDirectory);
1523         process->setProcessEnvironment(env);
1524         process->start(binary, arguments);
1525         success = process->waitForStarted();
1526         if (success)
1527             connect(process, SIGNAL(finished(int)), process, SLOT(deleteLater()));
1528         else
1529             delete process;
1530     } else {
1531         success = QProcess::startDetached(binary, arguments, workingDirectory);
1532     }
1533     if (!success) {
1534         const QString error = tr("Cannot launch \"%1\".").arg(binary);
1535         if (silent)
1536             outwin->appendSilently(error);
1537         else
1538             outwin->appendError(error);
1539     }
1540     return success;
1541 }
1542
1543 QString GitClient::gitBinaryPath(bool *ok, QString *errorMessage) const
1544 {
1545     return settings()->gitBinaryPath(ok, errorMessage);
1546 }
1547
1548 bool GitClient::getCommitData(const QString &workingDirectory,
1549                               bool amend,
1550                               QString *commitTemplate,
1551                               CommitData *commitData,
1552                               QString *errorMessage)
1553 {
1554     commitData->clear();
1555
1556     // Find repo
1557     const QString repoDirectory = GitClient::findRepositoryForDirectory(workingDirectory);
1558     if (repoDirectory.isEmpty()) {
1559         *errorMessage = msgRepositoryNotFound(workingDirectory);
1560         return false;
1561     }
1562
1563     commitData->panelInfo.repository = repoDirectory;
1564
1565     QDir gitDir(repoDirectory);
1566     if (!gitDir.cd(QLatin1String(kGitDirectoryC))) {
1567         *errorMessage = tr("The repository \"%1\" is not initialized.").arg(repoDirectory);
1568         return false;
1569     }
1570
1571     // Read description
1572     const QString descriptionFile = gitDir.absoluteFilePath(QLatin1String("description"));
1573     if (QFileInfo(descriptionFile).isFile()) {
1574         Utils::FileReader reader;
1575         if (!reader.fetch(descriptionFile, QIODevice::Text, errorMessage))
1576             return false;
1577         commitData->panelInfo.description = commandOutputFromLocal8Bit(reader.data()).trimmed();
1578     }
1579
1580     // Run status. Note that it has exitcode 1 if there are no added files.
1581     bool onBranch;
1582     QString output;
1583     const StatusResult status = gitStatus(repoDirectory, true, &output, errorMessage, &onBranch);
1584     switch (status) {
1585     case  StatusChanged:
1586         if (!onBranch) {
1587             *errorMessage = tr("You did not checkout a branch.");
1588             return false;
1589         }
1590         break;
1591     case StatusUnchanged:
1592         if (amend)
1593             break;
1594         *errorMessage = msgNoChangedFiles();
1595         return false;
1596     case StatusFailed:
1597         return false;
1598     }
1599
1600     //    Output looks like:
1601     //    # On branch [branchname]
1602     //    # Changes to be committed:
1603     //    #   (use "git reset HEAD <file>..." to unstage)
1604     //    #
1605     //    #       modified:   somefile.cpp
1606     //    #       new File:   somenew.h
1607     //    #
1608     //    # Changed but not updated:
1609     //    #   (use "git add <file>..." to update what will be committed)
1610     //    #
1611     //    #       modified:   someother.cpp
1612     //    #       modified:   submodule (modified content)
1613     //    #       modified:   submodule2 (new commit)
1614     //    #
1615     //    # Untracked files:
1616     //    #   (use "git add <file>..." to include in what will be committed)
1617     //    #
1618     //    #       list of files...
1619
1620     if (status != StatusUnchanged) {
1621         if (!commitData->parseFilesFromStatus(output)) {
1622             *errorMessage = msgParseFilesFailed();
1623             return false;
1624         }
1625         // Filter out untracked files that are not part of the project
1626         VCSBase::VCSBaseSubmitEditor::filterUntrackedFilesOfProject(repoDirectory, &commitData->untrackedFiles);
1627         if (commitData->filesEmpty()) {
1628             *errorMessage = msgNoChangedFiles();
1629             return false;
1630         }
1631     }
1632
1633     commitData->panelData.author = readConfigValue(workingDirectory, QLatin1String("user.name"));
1634     commitData->panelData.email = readConfigValue(workingDirectory, QLatin1String("user.email"));
1635
1636     // Get the commit template or the last commit message
1637     if (amend) {
1638         // Amend: get last commit data as "SHA1@message". TODO: Figure out codec.
1639         QStringList args(QLatin1String("log"));
1640         const QString format = synchronousGitVersion(true) > 0x010701 ? "%h@%B" : "%h@%s%n%n%b";
1641         args << QLatin1String("--max-count=1") << QLatin1String("--pretty=format:") + format;
1642         const Utils::SynchronousProcessResponse sp = synchronousGit(repoDirectory, args);
1643         if (sp.result != Utils::SynchronousProcessResponse::Finished) {
1644             *errorMessage = tr("Cannot retrieve last commit data of repository \"%1\".").arg(repoDirectory);
1645             return false;
1646         }
1647         const int separatorPos = sp.stdOut.indexOf(QLatin1Char('@'));
1648         QTC_ASSERT(separatorPos != -1, return false)
1649         commitData->amendSHA1= sp.stdOut.left(separatorPos);
1650         *commitTemplate = sp.stdOut.mid(separatorPos + 1);
1651     } else {
1652         // Commit: Get the commit template
1653         QString templateFilename = readConfigValue(workingDirectory, QLatin1String("commit.template"));
1654         if (!templateFilename.isEmpty()) {
1655             // Make relative to repository
1656             const QFileInfo templateFileInfo(templateFilename);
1657             if (templateFileInfo.isRelative())
1658                 templateFilename = repoDirectory + QLatin1Char('/') + templateFilename;
1659             Utils::FileReader reader;
1660             if (!reader.fetch(templateFilename, QIODevice::Text, errorMessage))
1661                 return false;
1662             *commitTemplate = QString::fromLocal8Bit(reader.data());
1663         }
1664     }
1665     return true;
1666 }
1667
1668 // Log message for commits/amended commits to go to output window
1669 static inline QString msgCommitted(const QString &amendSHA1, int fileCount)
1670 {
1671     if (amendSHA1.isEmpty())
1672         return GitClient::tr("Committed %n file(s).\n", 0, fileCount);
1673     if (fileCount)
1674         return GitClient::tr("Amended \"%1\" (%n file(s)).\n", 0, fileCount).arg(amendSHA1);
1675     return GitClient::tr("Amended \"%1\".").arg(amendSHA1);
1676 }
1677
1678 // addAndCommit:
1679 bool GitClient::addAndCommit(const QString &repositoryDirectory,
1680                              const GitSubmitEditorPanelData &data,
1681                              const QString &amendSHA1,
1682                              const QString &messageFile,
1683                              const QStringList &checkedFiles,
1684                              const QStringList &origCommitFiles,
1685                              const QStringList &origDeletedFiles)
1686 {
1687     const QString renamedSeparator = QLatin1String(" -> ");
1688     const bool amend = !amendSHA1.isEmpty();
1689
1690     // Do we need to reset any files that had been added before
1691     // (did the user uncheck any previously added files)
1692     // Split up  renamed files ('foo.cpp -> foo2.cpp').
1693     QStringList resetFiles = origCommitFiles.toSet().subtract(checkedFiles.toSet()).toList();
1694     for (QStringList::iterator it = resetFiles.begin(); it != resetFiles.end(); ++it) {
1695         const int renamedPos = it->indexOf(renamedSeparator);
1696         if (renamedPos != -1) {
1697             const QString newFile = it->mid(renamedPos + renamedSeparator.size());
1698             it->truncate(renamedPos);
1699             it = resetFiles.insert(++it, newFile);
1700         }
1701     }
1702
1703     if (!resetFiles.isEmpty())
1704         if (!synchronousReset(repositoryDirectory, resetFiles))
1705             return false;
1706
1707     // Re-add all to make sure we have the latest changes, but only add those that aren't marked
1708     // for deletion. Purge out renamed files ('foo.cpp -> foo2.cpp').
1709     QStringList addFiles = checkedFiles.toSet().subtract(origDeletedFiles.toSet()).toList();
1710     for (QStringList::iterator it = addFiles.begin(); it != addFiles.end(); ) {
1711         if (it->contains(renamedSeparator))
1712             it = addFiles.erase(it);
1713         else
1714             ++it;
1715     }
1716     if (!addFiles.isEmpty() && !synchronousAdd(repositoryDirectory, false, addFiles))
1717             return false;
1718
1719     // Do the final commit
1720     QStringList args;
1721     args << QLatin1String("commit")
1722          << QLatin1String("-F") << QDir::toNativeSeparators(messageFile);
1723     if (amend)
1724         args << QLatin1String("--amend");
1725     const QString &authorString =  data.authorString();
1726     if (!authorString.isEmpty())
1727          args << QLatin1String("--author") << authorString;
1728
1729     QByteArray outputText;
1730     QByteArray errorText;
1731     const bool rc = fullySynchronousGit(repositoryDirectory, args, &outputText, &errorText);
1732     if (rc)
1733         outputWindow()->append(msgCommitted(amendSHA1, checkedFiles.size()));
1734     else
1735         outputWindow()->appendError(tr("Cannot commit %n file(s): %1\n", 0, checkedFiles.size()).arg(commandOutputFromLocal8Bit(errorText)));
1736     return rc;
1737 }
1738
1739 /* Revert: This function can be called with a file list (to revert single
1740  * files)  or a single directory (revert all). Qt Creator currently has only
1741  * 'revert single' in its VCS menus, but the code is prepared to deal with
1742  * reverting a directory pending a sophisticated selection dialog in the
1743  * VCSBase plugin. */
1744 GitClient::RevertResult GitClient::revertI(QStringList files,
1745                                            bool *ptrToIsDirectory,
1746                                            QString *errorMessage,
1747                                            bool revertStaging)
1748 {
1749     if (files.empty())
1750         return RevertCanceled;
1751
1752     // Figure out the working directory
1753     const QFileInfo firstFile(files.front());
1754     const bool isDirectory = firstFile.isDir();
1755     if (ptrToIsDirectory)
1756         *ptrToIsDirectory = isDirectory;
1757     const QString workingDirectory = isDirectory ? firstFile.absoluteFilePath() : firstFile.absolutePath();
1758
1759     const QString repoDirectory = GitClient::findRepositoryForDirectory(workingDirectory);
1760     if (repoDirectory.isEmpty()) {
1761         *errorMessage = msgRepositoryNotFound(workingDirectory);
1762         return RevertFailed;
1763     }
1764
1765     // Check for changes
1766     QString output;
1767     switch (gitStatus(repoDirectory, false, &output, errorMessage)) {
1768     case StatusChanged:
1769         break;
1770     case StatusUnchanged:
1771         return RevertUnchanged;
1772     case StatusFailed:
1773         return RevertFailed;
1774     }
1775     CommitData data;
1776     if (!data.parseFilesFromStatus(output)) {
1777         *errorMessage = msgParseFilesFailed();
1778         return RevertFailed;
1779     }
1780
1781     // If we are looking at files, make them relative to the repository
1782     // directory to match them in the status output list.
1783     if (!isDirectory) {
1784         const QDir repoDir(repoDirectory);
1785         const QStringList::iterator cend = files.end();
1786         for (QStringList::iterator it = files.begin(); it != cend; ++it)
1787             *it = repoDir.relativeFilePath(*it);
1788     }
1789
1790     // From the status output, determine all modified [un]staged files.
1791     const QString modifiedState = QLatin1String("modified");
1792     const QStringList allStagedFiles = data.stagedFileNames(modifiedState);
1793     const QStringList allUnstagedFiles = data.unstagedFileNames(modifiedState);
1794     // Unless a directory was passed, filter all modified files for the
1795     // argument file list.
1796     QStringList stagedFiles = allStagedFiles;
1797     QStringList unstagedFiles = allUnstagedFiles;
1798     if (!isDirectory) {
1799         const QSet<QString> filesSet = files.toSet();
1800         stagedFiles = allStagedFiles.toSet().intersect(filesSet).toList();
1801         unstagedFiles = allUnstagedFiles.toSet().intersect(filesSet).toList();
1802     }
1803     if ((!revertStaging || stagedFiles.empty()) && unstagedFiles.empty())
1804         return RevertUnchanged;
1805
1806     // Ask to revert (to do: Handle lists with a selection dialog)
1807     const QMessageBox::StandardButton answer
1808         = QMessageBox::question(m_core->mainWindow(),
1809                                 tr("Revert"),
1810                                 tr("The file has been changed. Do you want to revert it?"),
1811                                 QMessageBox::Yes|QMessageBox::No,
1812                                 QMessageBox::No);
1813     if (answer == QMessageBox::No)
1814         return RevertCanceled;
1815
1816     // Unstage the staged files
1817     if (revertStaging && !stagedFiles.empty() && !synchronousReset(repoDirectory, stagedFiles, errorMessage))
1818         return RevertFailed;
1819     QStringList filesToRevert = unstagedFiles;
1820     if (revertStaging)
1821         filesToRevert += stagedFiles;
1822     // Finally revert!
1823     if (!synchronousCheckoutFiles(repoDirectory, filesToRevert, QString(), errorMessage, revertStaging))
1824         return RevertFailed;
1825     return RevertOk;
1826 }
1827
1828 void GitClient::revert(const QStringList &files, bool revertStaging)
1829 {
1830     bool isDirectory;
1831     QString errorMessage;
1832     switch (revertI(files, &isDirectory, &errorMessage, revertStaging)) {
1833     case RevertOk:
1834         GitPlugin::instance()->gitVersionControl()->emitFilesChanged(files);
1835         break;
1836     case RevertCanceled:
1837         break;
1838     case RevertUnchanged: {
1839         const QString msg = (isDirectory || files.size() > 1) ? msgNoChangedFiles() : tr("The file is not modified.");
1840         outputWindow()->append(msg);
1841     }
1842         break;
1843     case RevertFailed:
1844         outputWindow()->append(errorMessage);
1845         break;
1846     }
1847 }
1848
1849 bool GitClient::synchronousFetch(const QString &workingDirectory, const QString &remote)
1850 {
1851     QStringList arguments(QLatin1String("fetch"));
1852     if (!remote.isEmpty())
1853         arguments << remote;
1854     // Disable UNIX terminals to suppress SSH prompting.
1855     const unsigned flags = VCSBase::VCSBasePlugin::SshPasswordPrompt|VCSBase::VCSBasePlugin::ShowStdOutInLogWindow
1856                            |VCSBase::VCSBasePlugin::ShowSuccessMessage;
1857     const Utils::SynchronousProcessResponse resp = synchronousGit(workingDirectory, arguments, flags);
1858     return resp.result == Utils::SynchronousProcessResponse::Finished;
1859 }
1860
1861 bool GitClient::synchronousPull(const QString &workingDirectory)
1862 {
1863     return synchronousPull(workingDirectory, settings()->boolValue(GitSettings::pullRebaseKey));
1864 }
1865
1866 bool GitClient::synchronousPull(const QString &workingDirectory, bool rebase)
1867 {
1868     QStringList arguments(QLatin1String("pull"));
1869     if (rebase)
1870         arguments << QLatin1String("--rebase");
1871     // Disable UNIX terminals to suppress SSH prompting.
1872     const unsigned flags = VCSBase::VCSBasePlugin::SshPasswordPrompt|VCSBase::VCSBasePlugin::ShowStdOutInLogWindow;
1873     const Utils::SynchronousProcessResponse resp = synchronousGit(workingDirectory, arguments, flags);
1874     // Notify about changed files or abort the rebase.
1875     const bool ok = resp.result == Utils::SynchronousProcessResponse::Finished;
1876     if (ok) {
1877         GitPlugin::instance()->gitVersionControl()->emitRepositoryChanged(workingDirectory);
1878     } else {
1879         if (rebase)
1880             syncAbortPullRebase(workingDirectory);
1881     }
1882     return ok;
1883 }
1884
1885 void GitClient::syncAbortPullRebase(const QString &workingDir)
1886 {
1887     // Abort rebase to clean if something goes wrong
1888     VCSBase::VCSBaseOutputWindow *outwin = VCSBase::VCSBaseOutputWindow::instance();
1889     outwin->appendError(tr("The command 'git pull --rebase' failed, aborting rebase."));
1890     QStringList arguments;
1891     arguments << QLatin1String("rebase") << QLatin1String("--abort");
1892     QByteArray stdOut;
1893     QByteArray stdErr;
1894     const bool rc = fullySynchronousGit(workingDir, arguments, &stdOut, &stdErr, true);
1895     outwin->append(commandOutputFromLocal8Bit(stdOut));
1896     if (!rc)
1897         outwin->appendError(commandOutputFromLocal8Bit(stdErr));
1898 }
1899
1900 // Subversion: git svn
1901 void GitClient::synchronousSubversionFetch(const QString &workingDirectory)
1902 {
1903     QStringList args;
1904     args << QLatin1String("svn") << QLatin1String("fetch");
1905     // Disable UNIX terminals to suppress SSH prompting.
1906     const unsigned flags = VCSBase::VCSBasePlugin::SshPasswordPrompt|VCSBase::VCSBasePlugin::ShowStdOutInLogWindow
1907                            |VCSBase::VCSBasePlugin::ShowSuccessMessage;
1908     const Utils::SynchronousProcessResponse resp = synchronousGit(workingDirectory, args, flags);
1909     // Notify about changes.
1910     if (resp.result == Utils::SynchronousProcessResponse::Finished)
1911         GitPlugin::instance()->gitVersionControl()->emitRepositoryChanged(workingDirectory);
1912 }
1913
1914 void GitClient::subversionLog(const QString &workingDirectory)
1915 {
1916     QStringList arguments;
1917     arguments << QLatin1String("svn") << QLatin1String("log");
1918     int logCount = settings()->intValue(GitSettings::logCountKey);
1919     if (logCount > 0)
1920          arguments << (QLatin1String("--limit=") + QString::number(logCount));
1921
1922     // Create a command editor, no highlighting or interaction.
1923     const QString title = tr("Git SVN Log");
1924     const QString editorId = QLatin1String(Git::Constants::C_GIT_COMMAND_LOG_EDITOR);
1925     const QString sourceFile = VCSBase::VCSBaseEditorWidget::getSource(workingDirectory, QStringList());
1926     VCSBase::VCSBaseEditorWidget *editor = findExistingVCSEditor("svnLog", sourceFile);
1927     if (!editor)
1928         editor = createVCSEditor(editorId, title, sourceFile, false, "svnLog", sourceFile, 0);
1929     executeGit(workingDirectory, arguments, editor);
1930 }
1931
1932 bool GitClient::synchronousPush(const QString &workingDirectory)
1933 {
1934     // Disable UNIX terminals to suppress SSH prompting.
1935     const unsigned flags = VCSBase::VCSBasePlugin::SshPasswordPrompt|VCSBase::VCSBasePlugin::ShowStdOutInLogWindow
1936                            |VCSBase::VCSBasePlugin::ShowSuccessMessage;
1937     const Utils::SynchronousProcessResponse resp =
1938             synchronousGit(workingDirectory, QStringList(QLatin1String("push")), flags);
1939     return resp.result == Utils::SynchronousProcessResponse::Finished;
1940 }
1941
1942 QString GitClient::msgNoChangedFiles()
1943 {
1944     return tr("There are no modified files.");
1945 }
1946
1947 void GitClient::stashPop(const QString &workingDirectory)
1948 {
1949     QStringList arguments(QLatin1String("stash"));
1950     arguments << QLatin1String("pop");
1951     VCSBase::Command *cmd = executeGit(workingDirectory, arguments, 0, true);
1952     connectRepositoryChanged(workingDirectory, cmd);
1953 }
1954
1955 bool GitClient::synchronousStashRestore(const QString &workingDirectory,
1956                                         const QString &stash,
1957                                         const QString &branch /* = QString()*/,
1958                                         QString *errorMessage)
1959 {
1960     QStringList arguments(QLatin1String("stash"));
1961     if (branch.isEmpty())
1962         arguments << QLatin1String("apply") << stash;
1963     else
1964         arguments << QLatin1String("branch") << branch << stash;
1965     QByteArray outputText;
1966     QByteArray errorText;
1967     const bool rc = fullySynchronousGit(workingDirectory, arguments, &outputText, &errorText);
1968     if (!rc) {
1969         const QString stdErr = commandOutputFromLocal8Bit(errorText);
1970         const QString nativeWorkingDir = QDir::toNativeSeparators(workingDirectory);
1971         const QString msg = branch.isEmpty() ?
1972                             tr("Cannot restore stash \"%1\": %2").
1973                             arg(nativeWorkingDir, stdErr) :
1974                             tr("Cannot restore stash \"%1\" to branch \"%2\": %3").
1975                             arg(nativeWorkingDir, branch, stdErr);
1976         if (errorMessage)
1977             *errorMessage = msg;
1978         else
1979             outputWindow()->append(msg);
1980         return false;
1981     }
1982     QString output = commandOutputFromLocal8Bit(outputText);
1983     if (!output.isEmpty())
1984         outputWindow()->append(output);
1985     GitPlugin::instance()->gitVersionControl()->emitRepositoryChanged(workingDirectory);
1986     return true;
1987 }
1988
1989 bool GitClient::synchronousStashRemove(const QString &workingDirectory,
1990                             const QString &stash /* = QString() */,
1991                             QString *errorMessage /* = 0 */)
1992 {
1993     QStringList arguments(QLatin1String("stash"));
1994     if (stash.isEmpty()) {
1995         arguments << QLatin1String("clear");
1996     } else {
1997         arguments << QLatin1String("drop") << stash;
1998     }
1999     QByteArray outputText;
2000     QByteArray errorText;
2001     const bool rc = fullySynchronousGit(workingDirectory, arguments, &outputText, &errorText);
2002     if (!rc) {
2003         const QString stdErr = commandOutputFromLocal8Bit(errorText);
2004         const QString nativeWorkingDir = QDir::toNativeSeparators(workingDirectory);
2005         const QString msg = stash.isEmpty() ?
2006                             tr("Cannot remove stashes of \"%1\": %2").
2007                             arg(nativeWorkingDir, stdErr) :
2008                             tr("Cannot remove stash \"%1\" of \"%2\": %3").
2009                             arg(stash, nativeWorkingDir, stdErr);
2010         if (errorMessage)
2011             *errorMessage = msg;
2012         else
2013             outputWindow()->append(msg);
2014         return false;
2015     }
2016     QString output = commandOutputFromLocal8Bit(outputText);
2017     if (!output.isEmpty())
2018         outputWindow()->append(output);
2019     return true;
2020 }
2021
2022 void GitClient::branchList(const QString &workingDirectory)
2023 {
2024     QStringList arguments(QLatin1String("branch"));
2025     arguments << QLatin1String("-r") << QLatin1String(noColorOption);
2026     executeGit(workingDirectory, arguments, 0, true);
2027 }
2028
2029 void GitClient::stashList(const QString &workingDirectory)
2030 {
2031     QStringList arguments(QLatin1String("stash"));
2032     arguments << QLatin1String("list") << QLatin1String(noColorOption);
2033     executeGit(workingDirectory, arguments, 0, true);
2034 }
2035
2036 bool GitClient::synchronousStashList(const QString &workingDirectory,
2037                                      QList<Stash> *stashes,
2038                                      QString *errorMessage /* = 0 */)
2039 {
2040     stashes->clear();
2041     QStringList arguments(QLatin1String("stash"));
2042     arguments << QLatin1String("list") << QLatin1String(noColorOption);
2043     QByteArray outputText;
2044     QByteArray errorText;
2045     const bool rc = fullySynchronousGit(workingDirectory, arguments, &outputText, &errorText);
2046     if (!rc) {
2047         const QString msg = tr("Cannot retrieve stash list of \"%1\": %2").
2048                             arg(QDir::toNativeSeparators(workingDirectory),
2049                                 commandOutputFromLocal8Bit(errorText));
2050         if (errorMessage) {
2051             *errorMessage = msg;
2052         } else {
2053             outputWindow()->append(msg);
2054         }
2055         return false;
2056     }
2057     Stash stash;
2058     foreach(const QString &line, commandOutputLinesFromLocal8Bit(outputText))
2059         if (stash.parseStashLine(line))
2060             stashes->push_back(stash);
2061     return true;
2062 }
2063
2064 QString GitClient::readConfig(const QString &workingDirectory, const QStringList &configVar)
2065 {
2066     QStringList arguments;
2067     arguments << QLatin1String("config") << configVar;
2068
2069     QByteArray outputText;
2070     QByteArray errorText;
2071     if (fullySynchronousGit(workingDirectory, arguments, &outputText, &errorText, false))
2072         return commandOutputFromLocal8Bit(outputText);
2073     return QString();
2074 }
2075
2076 // Read a single-line config value, return trimmed
2077 QString GitClient::readConfigValue(const QString &workingDirectory, const QString &configVar)
2078 {
2079     return readConfig(workingDirectory, QStringList(configVar)).remove(QLatin1Char('\n'));
2080 }
2081
2082 bool GitClient::cloneRepository(const QString &directory,const QByteArray &url)
2083 {
2084     QDir workingDirectory(directory);
2085     const unsigned flags = VCSBase::VCSBasePlugin::SshPasswordPrompt |
2086             VCSBase::VCSBasePlugin::ShowStdOutInLogWindow|
2087             VCSBase::VCSBasePlugin::ShowSuccessMessage;
2088
2089     if (workingDirectory.exists()) {
2090         if (!synchronousInit(workingDirectory.path()))
2091             return false;
2092
2093         QStringList arguments(QLatin1String("remote"));
2094         arguments << QLatin1String("add") << QLatin1String("origin") << url;
2095         if (!fullySynchronousGit(workingDirectory.path(), arguments, 0, 0, true))
2096             return false;
2097
2098         arguments.clear();
2099         arguments << QLatin1String("fetch");
2100         const Utils::SynchronousProcessResponse resp =
2101                 synchronousGit(workingDirectory.path(), arguments, flags);
2102         if (resp.result != Utils::SynchronousProcessResponse::Finished)
2103             return false;
2104
2105         arguments.clear();
2106         arguments << QLatin1String("config")
2107                   << QLatin1String("branch.master.remote")
2108                   <<  QLatin1String("origin");
2109         if (!fullySynchronousGit(workingDirectory.path(), arguments, 0, 0, true))
2110             return false;
2111
2112         arguments.clear();
2113         arguments << QLatin1String("config")
2114                   << QLatin1String("branch.master.merge")
2115                   << QLatin1String("refs/heads/master");
2116         if (!fullySynchronousGit(workingDirectory.path(), arguments, 0, 0, true))
2117             return false;
2118
2119         return true;
2120     } else {
2121         QStringList arguments(QLatin1String("clone"));
2122         arguments << url << workingDirectory.dirName();
2123         workingDirectory.cdUp();
2124         const Utils::SynchronousProcessResponse resp =
2125                 synchronousGit(workingDirectory.path(), arguments, flags);
2126         // TODO: Turn this into a VCSBaseClient and use resetCachedVcsInfo(...)
2127         Core::VcsManager *vcsManager = m_core->vcsManager();
2128         vcsManager->resetVersionControlForDirectory(workingDirectory.absolutePath());
2129         return (resp.result == Utils::SynchronousProcessResponse::Finished);
2130     }
2131 }
2132
2133 QString GitClient::vcsGetRepositoryURL(const QString &directory)
2134 {
2135     QStringList arguments(QLatin1String("config"));
2136     QByteArray outputText;
2137
2138     arguments << QLatin1String("remote.origin.url");
2139
2140     if (fullySynchronousGit(directory, arguments, &outputText, 0, false))
2141         return commandOutputFromLocal8Bit(outputText);
2142     return QString();
2143 }
2144
2145 GitSettings *GitClient::settings() const
2146 {
2147     return m_settings;
2148 }
2149
2150 void GitClient::connectRepositoryChanged(const QString & repository, VCSBase::Command *cmd)
2151 {
2152     // Bind command success termination with repository to changed signal
2153     if (!m_repositoryChangedSignalMapper) {
2154         m_repositoryChangedSignalMapper = new QSignalMapper(this);
2155         connect(m_repositoryChangedSignalMapper, SIGNAL(mapped(QString)),
2156                 GitPlugin::instance()->gitVersionControl(), SIGNAL(repositoryChanged(QString)));
2157     }
2158     m_repositoryChangedSignalMapper->setMapping(cmd, repository);
2159     connect(cmd, SIGNAL(success()), m_repositoryChangedSignalMapper, SLOT(map()),
2160             Qt::QueuedConnection);
2161 }
2162
2163 // determine version as '(major << 16) + (minor << 8) + patch' or 0.
2164 unsigned GitClient::gitVersion(bool silent, QString *errorMessage) const
2165 {
2166     const QString newGitBinary = gitBinaryPath();
2167     if (m_gitVersionForBinary != newGitBinary && !newGitBinary.isEmpty()) {
2168         // Do not execute repeatedly if that fails (due to git
2169         // not being installed) until settings are changed.
2170         m_cachedGitVersion = synchronousGitVersion(silent, errorMessage);
2171         m_gitVersionForBinary = newGitBinary;
2172     }
2173     return m_cachedGitVersion;
2174 }
2175
2176 QString GitClient::gitVersionString(bool silent, QString *errorMessage) const
2177 {
2178     if (const unsigned version = gitVersion(silent, errorMessage)) {
2179         QString rc;
2180         QTextStream(&rc) << (version >> 16) << '.'
2181                 << (0xFF & (version >> 8)) << '.'
2182                 << (version & 0xFF);
2183         return rc;
2184     }
2185     return QString();
2186 }
2187 // determine version as '(major << 16) + (minor << 8) + patch' or 0.
2188 unsigned GitClient::synchronousGitVersion(bool silent, QString *errorMessage) const
2189 {
2190     // run git --version
2191     QByteArray outputText;
2192     QByteArray errorText;
2193     const bool rc = fullySynchronousGit(QString(), QStringList("--version"), &outputText, &errorText);
2194     if (!rc) {
2195         const QString msg = tr("Cannot determine git version: %1").arg(commandOutputFromLocal8Bit(errorText));
2196         if (errorMessage) {
2197             *errorMessage = msg;
2198         } else {
2199             if (silent) {
2200                 outputWindow()->append(msg);
2201             } else {
2202                 outputWindow()->appendError(msg);
2203             }
2204         }
2205         return 0;
2206     }
2207     // cut 'git version 1.6.5.1.sha'
2208     const QString output = commandOutputFromLocal8Bit(outputText);
2209     const QRegExp versionPattern(QLatin1String("^[^\\d]+([\\d])\\.([\\d])\\.([\\d]).*$"));
2210     QTC_ASSERT(versionPattern.isValid(), return 0);
2211     QTC_ASSERT(versionPattern.exactMatch(output), return 0);
2212     const unsigned major = versionPattern.cap(1).toUInt();
2213     const unsigned minor = versionPattern.cap(2).toUInt();
2214     const unsigned patch = versionPattern.cap(3).toUInt();
2215     return version(major, minor, patch);
2216 }
2217
2218 } // namespace Internal
2219 } // namespace Git
2220
2221 #include "gitclient.moc"