gitclient.cpp

    QByteArray outputText;
    QByteArray errorText;
    const bool rc = fullySynchronousGit(workingDirectory, arguments, &outputText, &errorText);
    if (!rc) {
        const QString msg = tr("Cannot retrieve stash list of \"%1\": %2").
                            arg(QDir::toNativeSeparators(workingDirectory),
                                commandOutputFromLocal8Bit(errorText));
        if (errorMessage)
            *errorMessage = msg;
        else
            outputWindow()->append(msg);
        return false;
    }
    Stash stash;
    foreach (const QString &line, commandOutputLinesFromLocal8Bit(outputText))
        if (stash.parseStashLine(line))
            stashes->push_back(stash);
    return true;
}

QString GitClient::readConfig(const QString &workingDirectory, const QStringList &configVar) const
{
    QStringList arguments;
    arguments << QLatin1String("config") << configVar;

    QByteArray outputText;
    QByteArray errorText;
    if (!fullySynchronousGit(workingDirectory, arguments, &outputText, &errorText, false))
        return QString();
    if (Utils::HostOsInfo::isWindowsHost())
        return QString::fromUtf8(outputText).remove(QLatin1Char('\r'));
    return commandOutputFromLocal8Bit(outputText);
}

// Read a single-line config value, return trimmed
QString GitClient::readConfigValue(const QString &workingDirectory, const QString &configVar) const
{
    return readConfig(workingDirectory, QStringList(configVar)).remove(QLatin1Char('\n'));
}

bool GitClient::cloneRepository(const QString &directory,const QByteArray &url)
{
    QDir workingDirectory(directory);
    const unsigned flags = VcsBase::VcsBasePlugin::SshPasswordPrompt |
            VcsBase::VcsBasePlugin::ShowStdOutInLogWindow|
            VcsBase::VcsBasePlugin::ShowSuccessMessage;

    if (workingDirectory.exists()) {
        if (!synchronousInit(workingDirectory.path()))
            return false;

        QStringList arguments(QLatin1String("remote"));
        arguments << QLatin1String("add") << QLatin1String("origin") << QLatin1String(url);
        if (!fullySynchronousGit(workingDirectory.path(), arguments, 0, 0, true))
            return false;

        arguments.clear();
        arguments << QLatin1String("fetch");
        const Utils::SynchronousProcessResponse resp =
                synchronousGit(workingDirectory.path(), arguments, flags);
        if (resp.result != Utils::SynchronousProcessResponse::Finished)
            return false;

        arguments.clear();
        arguments << QLatin1String("config")
                  << QLatin1String("branch.master.remote")
                  <<  QLatin1String("origin");
        if (!fullySynchronousGit(workingDirectory.path(), arguments, 0, 0, true))
            return false;

        arguments.clear();
        arguments << QLatin1String("config")
                  << QLatin1String("branch.master.merge")
                  << QLatin1String("refs/heads/master");
        if (!fullySynchronousGit(workingDirectory.path(), arguments, 0, 0, true))
            return false;

        return true;
    } else {
        QStringList arguments(QLatin1String("clone"));
        arguments << QLatin1String(url) << workingDirectory.dirName();
        workingDirectory.cdUp();
        const Utils::SynchronousProcessResponse resp =
                synchronousGit(workingDirectory.path(), arguments, flags);
        // TODO: Turn this into a VcsBaseClient and use resetCachedVcsInfo(...)
        Core::ICore::vcsManager()->resetVersionControlForDirectory(workingDirectory.absolutePath());
        return (resp.result == Utils::SynchronousProcessResponse::Finished);
    }
}

QString GitClient::vcsGetRepositoryURL(const QString &directory)
{
    QStringList arguments(QLatin1String("config"));
    QByteArray outputText;

    arguments << QLatin1String("remote.origin.url");

    if (fullySynchronousGit(directory, arguments, &outputText, 0, false))
        return commandOutputFromLocal8Bit(outputText);
    return QString();
}

GitSettings *GitClient::settings() const
{
    return m_settings;
}

void GitClient::connectRepositoryChanged(const QString & repository, VcsBase::Command *cmd)
{
    // Bind command success termination with repository to changed signal
    if (!m_repositoryChangedSignalMapper) {
        m_repositoryChangedSignalMapper = new QSignalMapper(this);
        connect(m_repositoryChangedSignalMapper, SIGNAL(mapped(QString)),
                GitPlugin::instance()->gitVersionControl(), SIGNAL(repositoryChanged(QString)));
    }
    m_repositoryChangedSignalMapper->setMapping(cmd, repository);
    connect(cmd, SIGNAL(success(QVariant)), m_repositoryChangedSignalMapper, SLOT(map()),
            Qt::QueuedConnection);
}

// determine version as '(major << 16) + (minor << 8) + patch' or 0.
unsigned GitClient::gitVersion(QString *errorMessage) const
{
    const QString newGitBinary = gitBinaryPath();
    if (m_gitVersionForBinary != newGitBinary && !newGitBinary.isEmpty()) {
        // Do not execute repeatedly if that fails (due to git
        // not being installed) until settings are changed.
        m_cachedGitVersion = synchronousGitVersion(errorMessage);
        m_gitVersionForBinary = newGitBinary;
    }
    return m_cachedGitVersion;
}

// determine version as '(major << 16) + (minor << 8) + patch' or 0.
unsigned GitClient::synchronousGitVersion(QString *errorMessage) const
{
    if (gitBinaryPath().isEmpty())
        return 0;

    // run git --version
    QByteArray outputText;
    QByteArray errorText;
    const bool rc = fullySynchronousGit(QString(), QStringList(QLatin1String("--version")), &outputText, &errorText, false);
    if (!rc) {
        const QString msg = tr("Cannot determine git version: %1").arg(commandOutputFromLocal8Bit(errorText));
        if (errorMessage)
            *errorMessage = msg;
        else
            outputWindow()->append(msg);
        return 0;
    }
    // cut 'git version 1.6.5.1.sha'
    const QString output = commandOutputFromLocal8Bit(outputText);
    QRegExp versionPattern(QLatin1String("^[^\\d]+(\\d+)\\.(\\d+)\\.(\\d+).*$"));
    QTC_ASSERT(versionPattern.isValid(), return 0);
    QTC_ASSERT(versionPattern.exactMatch(output), return 0);
    const unsigned major = versionPattern.cap(1).toUInt(0, 16);
    const unsigned minor = versionPattern.cap(2).toUInt(0, 16);
    const unsigned patch = versionPattern.cap(3).toUInt(0, 16);
    return version(major, minor, patch);
}

GitClient::StashGuard::StashGuard(const QString &workingDirectory, const QString &keyword,
                                  StashFlag flag) :
    pop(true),
    workingDir(workingDirectory),
    flags(flag)
{
    client = GitPlugin::instance()->gitClient();
    QString errorMessage;
    if (flags & NoPrompt)
        executeStash(keyword, &errorMessage);
    else
        stashPrompt(keyword, &errorMessage);

    if (stashResult == StashFailed)
        VcsBase::VcsBaseOutputWindow::instance()->appendError(errorMessage);
}

GitClient::StashGuard::~StashGuard()
{
    if (pop && stashResult == Stashed) {
        QString stashName;
        if (client->stashNameFromMessage(workingDir, message, &stashName))
            client->stashPop(workingDir, stashName);
    }
}

void GitClient::StashGuard::stashPrompt(const QString &keyword, QString *errorMessage)
{
    QString statusOutput;
    switch (client->gitStatus(workingDir, StatusMode(NoUntracked | NoSubmodules),
                              &statusOutput, errorMessage)) {
    case GitClient::StatusChanged:
        break;
    case GitClient::StatusUnchanged:
        stashResult = StashUnchanged;
        return;
    case GitClient::StatusFailed:
        stashResult = StashFailed;
        return;
    }

    QPointer<QMessageBox> msgBox = new QMessageBox(QMessageBox::Question,
                                   tr("Uncommitted Changes Found"),
                                   tr("What would you like to do with local changes in:")
                                        + QLatin1String("\n\n\"") + workingDir + QLatin1Char('\"'),
                                   QMessageBox::NoButton, Core::ICore::mainWindow());

    msgBox->setDetailedText(statusOutput);

    QPushButton *stashButton = msgBox->addButton(tr("Stash"), QMessageBox::AcceptRole);
    stashButton->setToolTip(tr("Stash local changes and continue."));

    QPushButton *discardButton = msgBox->addButton(tr("Discard"), QMessageBox::AcceptRole);
    discardButton->setToolTip(tr("Discard (reset) local changes and continue."));

    QPushButton *ignoreButton = 0;
    if (flags & AllowUnstashed) {
        ignoreButton = msgBox->addButton(QMessageBox::Ignore);
        ignoreButton->setToolTip(tr("Continue with local changes in working directory."));
    }

    QPushButton *cancelButton = msgBox->addButton(QMessageBox::Cancel);
    cancelButton->setToolTip(tr("Cancel current command."));

    msgBox->exec();

    if (msgBox.isNull())
        return;

    if (msgBox->clickedButton() == discardButton) {
        if (!client->synchronousReset(workingDir, QStringList(), errorMessage))
            stashResult = StashFailed;
        else
            stashResult = StashUnchanged;
    } else if (msgBox->clickedButton() == ignoreButton) { // At your own risk, so.
        stashResult = NotStashed;
    } else if (msgBox->clickedButton() == cancelButton) {
        stashResult = StashCanceled;
    } else if (msgBox->clickedButton() == stashButton) {
        executeStash(keyword, errorMessage);
    }
}

void GitClient::StashGuard::executeStash(const QString &keyword, QString *errorMessage)
{
    message = creatorStashMessage(keyword);
    if (!client->executeSynchronousStash(workingDir, message, errorMessage))
        stashResult = StashFailed;
    else
        stashResult = Stashed;
 }

void GitClient::StashGuard::preventPop()
{
    pop = false;
}

bool GitClient::StashGuard::stashingFailed() const
{
    switch (stashResult) {
    case StashCanceled:
    case StashFailed:
        return true;
    case NotStashed:
        return !(flags & AllowUnstashed);
    default:
        return false;
    }
}

} // namespace Internal
} // namespace Git

#include "gitclient.moc"