vcsbase: add mechanism to ease management of VCS settings

Management of VCS settings was rather laborious (see BazaarSettings,
GitSettings, ...).
To overcome this, the base class VCSBaseClientSettings is now
equipped with a mechanism factorizing redundant code for VCS settings,
like operator=(), operator==(), writeSettings(), ...
Heir classes of VCSBaseClientSettings only need to declare the
settings (key + default value).

Bazaar and Mercurial plugins are impacted.

Change-Id: I7e4093a6d9476f3c8954f4d104f1b26ac185beb9
Merge-request: 2204
Reviewed-by: Tobias Hunger <tobias.hunger@nokia.com>
Reviewed-on: http://codereview.qt-project.org/4889
Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com>

20 files changed, 433 insertions, 328 deletions

diff --git a/src/plugins/bazaar/bazaarclient.cpp b/src/plugins/bazaar/bazaarclient.cpp
index 966761913b..d38bc9d3de 100644
--- a/src/plugins/bazaar/bazaarclient.cpp
+++ b/src/plugins/bazaar/bazaarclient.cpp
@@ -62,7 +62,9 @@ bool BazaarClient::synchronousSetUserId()
 {
     QStringList args;
     args << QLatin1String("whoami")
-         << QString("%1 <%2>").arg(settings()->userName()).arg(settings()->email());
+         << QString("%1 <%2>")
+            .arg(settings()->stringValue(BazaarSettings::userNameKey))
+            .arg(settings()->stringValue(BazaarSettings::userEmailKey));
     QByteArray stdOut;
     return vcsFullySynchronousExec(QDir::currentPath(), args, &stdOut);
 }
@@ -217,9 +219,9 @@ public:
         VCSBase::VCSBaseEditorParameterWidget(parent), m_client(client), m_params(p)
     {
         mapSetting(addToggleButton(QLatin1String("-w"), tr("Ignore whitespace")),
-                   &client->settings()->diffIgnoreWhiteSpace);
+                   client->settings()->boolPointer(BazaarSettings::diffIgnoreWhiteSpaceKey));
         mapSetting(addToggleButton(QLatin1String("-B"), tr("Ignore blank lines")),
-                   &client->settings()->diffIgnoreBlankLines);
+                   client->settings()->boolPointer(BazaarSettings::diffIgnoreBlankLinesKey));
     }
 
     QStringList arguments() const
@@ -262,13 +264,13 @@ public:
     {
         mapSetting(addToggleButton(QLatin1String("--verbose"), tr("Verbose"),
                                    tr("Show files changed in each revision")),
-                   &m_client->settings()->logVerbose);
+                   m_client->settings()->boolPointer(BazaarSettings::logVerboseKey));
         mapSetting(addToggleButton(QLatin1String("--forward"), tr("Forward"),
                                    tr("Show from oldest to newest")),
-                   &m_client->settings()->logForward);
+                   m_client->settings()->boolPointer(BazaarSettings::logForwardKey));
         mapSetting(addToggleButton(QLatin1String("--include-merges"), tr("Include merges"),
                                    tr("Show merged revisions")),
-                   &m_client->settings()->logIncludeMerges);
+                   m_client->settings()->boolPointer(BazaarSettings::logIncludeMergesKey));
 
         QList<ComboBoxItem> logChoices;
         logChoices << ComboBoxItem(tr("Detailed"), QLatin1String("long"))
@@ -276,7 +278,7 @@ public:
                    << ComboBoxItem(tr("One line"), QLatin1String("line"))
                    << ComboBoxItem(tr("GNU ChangeLog"), QLatin1String("gnu-changelog"));
         mapSetting(addComboBox(QLatin1String("--log-format"), logChoices),
-                   &m_client->settings()->logFormat);
+                   m_client->settings()->stringPointer(BazaarSettings::logFormatKey));
     }
 
     void executeCommand()
diff --git a/src/plugins/bazaar/bazaarcontrol.cpp b/src/plugins/bazaar/bazaarcontrol.cpp
index 59d6e40468..ce255d2b1d 100644
--- a/src/plugins/bazaar/bazaarcontrol.cpp
+++ b/src/plugins/bazaar/bazaarcontrol.cpp
@@ -69,7 +69,7 @@ bool BazaarControl::managesDirectory(const QString &directory, QString *topLevel
 
 bool BazaarControl::isConfigured() const
 {
-    const QString binary = m_bazaarClient->settings()->binary();
+    const QString binary = m_bazaarClient->settings()->stringValue(BazaarSettings::binaryPathKey);
     if (binary.isEmpty())
         return false;
     QFileInfo fi(binary);
diff --git a/src/plugins/bazaar/bazaarplugin.cpp b/src/plugins/bazaar/bazaarplugin.cpp
index 063455e6f7..d1354c3550 100644
--- a/src/plugins/bazaar/bazaarplugin.cpp
+++ b/src/plugins/bazaar/bazaarplugin.cpp
@@ -391,7 +391,7 @@ void BazaarPlugin::logRepository()
     const VCSBase::VCSBasePluginState state = currentState();
     QTC_ASSERT(state.hasTopLevel(), return);
     QStringList extraOptions;
-    extraOptions += QString("--limit=%1").arg(settings().logCount());
+    extraOptions += QString("--limit=%1").arg(settings().intValue(BazaarSettings::logCountKey));
     m_client->log(state.topLevel(), QStringList(), extraOptions);
 }
 
@@ -592,8 +592,8 @@ void BazaarPlugin::showCommitWidget(const QList<VCSBase::VCSBaseClient::StatusIt
     commitEditor->setDisplayName(msg);
 
     const BranchInfo branch = m_client->synchronousBranchQuery(m_submitRepository);
-    commitEditor->setFields(branch, m_bazaarSettings.userName(),
-                            m_bazaarSettings.email(), status);
+    commitEditor->setFields(branch, m_bazaarSettings.stringValue(BazaarSettings::userNameKey),
+                            m_bazaarSettings.stringValue(BazaarSettings::userEmailKey), status);
 
     commitEditor->registerActions(m_editorUndo, m_editorRedo, m_editorCommit, m_editorDiff);
     connect(commitEditor, SIGNAL(diffSelectedFiles(QStringList)),
@@ -624,11 +624,11 @@ bool BazaarPlugin::submitEditorAboutToClose(VCSBase::VCSBaseSubmitEditor *submit
     if (!editorFile || !commitEditor)
         return true;
 
-    bool dummyPrompt = m_bazaarSettings.prompt();
+    bool dummyPrompt = m_bazaarSettings.boolValue(BazaarSettings::promptOnSubmitKey);
     const VCSBase::VCSBaseSubmitEditor::PromptSubmitResult response =
             commitEditor->promptSubmit(tr("Close Commit Editor"), tr("Do you want to commit the changes?"),
                                        tr("Message check failed. Do you want to proceed?"),
-                                       &dummyPrompt, m_bazaarSettings.prompt());
+                                       &dummyPrompt, dummyPrompt);
 
     switch (response) {
     case VCSBase::VCSBaseSubmitEditor::SubmitCanceled:
diff --git a/src/plugins/bazaar/bazaarsettings.cpp b/src/plugins/bazaar/bazaarsettings.cpp
index bede461bc5..1b2ab233b5 100644
--- a/src/plugins/bazaar/bazaarsettings.cpp
+++ b/src/plugins/bazaar/bazaarsettings.cpp
@@ -38,81 +38,30 @@
 namespace Bazaar {
 namespace Internal {
 
-const QLatin1String diffIgnoreWhiteSpaceKey("diffIgnoreWhiteSpace");
-const QLatin1String diffIgnoreBlankLinesKey("diffIgnoreBlankLines");
-const QLatin1String logVerboseKey("logVerbose");
-const QLatin1String logForwardKey("logForward");
-const QLatin1String logIncludeMergesKey("logIncludeMerges");
-const QLatin1String logFormatKey("logFormat");
+const QLatin1String BazaarSettings::diffIgnoreWhiteSpaceKey("diffIgnoreWhiteSpace");
+const QLatin1String BazaarSettings::diffIgnoreBlankLinesKey("diffIgnoreBlankLines");
+const QLatin1String BazaarSettings::logVerboseKey("logVerbose");
+const QLatin1String BazaarSettings::logForwardKey("logForward");
+const QLatin1String BazaarSettings::logIncludeMergesKey("logIncludeMerges");
+const QLatin1String BazaarSettings::logFormatKey("logFormat");
 
-BazaarSettings::BazaarSettings() :
-    diffIgnoreWhiteSpace(false),
-    diffIgnoreBlankLines(false),
-    logVerbose(false),
-    logForward(false),
-    logIncludeMerges(false),
-    logFormat(QLatin1String("long"))
+BazaarSettings::BazaarSettings()
 {
     setSettingsGroup(QLatin1String(Constants::BAZAAR));
-    setDefaultBinary(QLatin1String(Constants::BAZAARDEFAULT));
-}
-
-BazaarSettings& BazaarSettings::operator=(const BazaarSettings& other)
-{
-    VCSBase::VCSBaseClientSettings::operator=(other);
-    if (this != &other) {
-        diffIgnoreWhiteSpace = other.diffIgnoreWhiteSpace;
-        diffIgnoreBlankLines = other.diffIgnoreBlankLines;
-        logVerbose = other.logVerbose;
-        logForward = other.logForward;
-        logIncludeMerges = other.logIncludeMerges;
-        logFormat = other.logFormat;
-    }
-    return *this;
+    // Override default binary path
+    declareKey(binaryPathKey, QLatin1String(Constants::BAZAARDEFAULT));
+    declareKey(diffIgnoreWhiteSpaceKey, false);
+    declareKey(diffIgnoreBlankLinesKey, false);
+    declareKey(logVerboseKey, false);
+    declareKey(logForwardKey, false);
+    declareKey(logIncludeMergesKey, false);
+    declareKey(logFormatKey, QLatin1String("long"));
 }
 
 bool BazaarSettings::sameUserId(const BazaarSettings& other) const
 {
-    return userName() == other.userName() && email() == other.email();
-}
-
-void BazaarSettings::writeSettings(QSettings *settings) const
-{
-    VCSBaseClientSettings::writeSettings(settings);
-    settings->beginGroup(settingsGroup());
-    settings->setValue(diffIgnoreWhiteSpaceKey, diffIgnoreWhiteSpace);
-    settings->setValue(diffIgnoreBlankLinesKey, diffIgnoreBlankLines);
-    settings->setValue(logVerboseKey, logVerbose);
-    settings->setValue(logForwardKey, logForward);
-    settings->setValue(logIncludeMergesKey, logIncludeMerges);
-    settings->setValue(logFormatKey, logFormat);
-    settings->endGroup();
-}
-
-void BazaarSettings::readSettings(const QSettings *settings)
-{
-    VCSBaseClientSettings::readSettings(settings);
-    const QString keyRoot = settingsGroup() + QLatin1Char('/');
-    diffIgnoreWhiteSpace = settings->value(keyRoot + diffIgnoreWhiteSpaceKey, false).toBool();
-    diffIgnoreBlankLines = settings->value(keyRoot + diffIgnoreBlankLinesKey, false).toBool();
-    logVerbose = settings->value(keyRoot + logVerboseKey, false).toBool();
-    logForward = settings->value(keyRoot + logForwardKey, false).toBool();
-    logIncludeMerges = settings->value(keyRoot + logIncludeMergesKey, false).toBool();
-    logFormat = settings->value(keyRoot + logFormatKey, QLatin1String("long")).toString();
-}
-
-bool BazaarSettings::equals(const VCSBaseClientSettings &rhs) const
-{
-    const BazaarSettings *bzrRhs = dynamic_cast<const BazaarSettings *>(&rhs);
-    if (bzrRhs == 0)
-        return false;
-    return VCSBaseClientSettings::equals(rhs)
-            && diffIgnoreWhiteSpace == bzrRhs->diffIgnoreWhiteSpace
-            && diffIgnoreBlankLines == bzrRhs->diffIgnoreBlankLines
-            && logVerbose == bzrRhs->logVerbose
-            && logForward == bzrRhs->logForward
-            && logIncludeMerges == bzrRhs->logIncludeMerges
-            && logFormat == bzrRhs->logFormat;
+    return stringValue(userNameKey) == other.stringValue(userNameKey) &&
+            stringValue(userEmailKey) == other.stringValue(userEmailKey);
 }
 
 } // namespace Internal
diff --git a/src/plugins/bazaar/bazaarsettings.h b/src/plugins/bazaar/bazaarsettings.h
index 32040b307b..8ac01d13b4 100644
--- a/src/plugins/bazaar/bazaarsettings.h
+++ b/src/plugins/bazaar/bazaarsettings.h
@@ -41,21 +41,15 @@ namespace Internal {
 class BazaarSettings : public VCSBase::VCSBaseClientSettings
 {
 public:
+    static const QLatin1String diffIgnoreWhiteSpaceKey;
+    static const QLatin1String diffIgnoreBlankLinesKey;
+    static const QLatin1String logVerboseKey;
+    static const QLatin1String logForwardKey;
+    static const QLatin1String logIncludeMergesKey;
+    static const QLatin1String logFormatKey;
+
     BazaarSettings();
-    BazaarSettings& operator=(const BazaarSettings& other);
     bool sameUserId(const BazaarSettings& other) const;
-
-    virtual void writeSettings(QSettings *settings) const;
-    virtual void readSettings(const QSettings *settings);
-    virtual bool equals(const VCSBaseClientSettings &rhs) const;
-
-    bool diffIgnoreWhiteSpace;
-    bool diffIgnoreBlankLines;
-
-    bool logVerbose;
-    bool logForward;
-    bool logIncludeMerges;
-    QString logFormat;
 };
 
 } // namespace Internal
diff --git a/src/plugins/bazaar/clonewizard.cpp b/src/plugins/bazaar/clonewizard.cpp
index c8c17eed03..fc900f8d6a 100644
--- a/src/plugins/bazaar/clonewizard.cpp
+++ b/src/plugins/bazaar/clonewizard.cpp
@@ -89,7 +89,6 @@ QSharedPointer<VCSBase::AbstractCheckoutJob> CloneWizard::createJob(const QList<
         return QSharedPointer<VCSBase::AbstractCheckoutJob>();
 
     const BazaarSettings &settings = BazaarPlugin::instance()->settings();
-    QStringList args = settings.standardArguments();
     *checkoutPath = page->path() + QLatin1Char('/') + page->directory();
 
     const CloneOptionsPanel *panel = page->cloneOptionsPanel();
@@ -111,10 +110,11 @@ QSharedPointer<VCSBase::AbstractCheckoutJob> CloneWizard::createJob(const QList<
     if (!panel->revision().isEmpty())
         extraOptions << QLatin1String("-r") << panel->revision();
     const BazaarClient *client = BazaarPlugin::instance()->client();
+    QStringList args;
     args << client->vcsCommandString(BazaarClient::CloneCommand)
          << extraOptions << page->repository() << page->directory();
 
     VCSBase::ProcessCheckoutJob *job = new VCSBase::ProcessCheckoutJob;
-    job->addStep(settings.binary(), args, page->path());
+    job->addStep(settings.stringValue(BazaarSettings::binaryPathKey), args, page->path());
     return QSharedPointer<VCSBase::AbstractCheckoutJob>(job);
 }
diff --git a/src/plugins/bazaar/optionspage.cpp b/src/plugins/bazaar/optionspage.cpp
index 457e450237..96a7b8fbe4 100644
--- a/src/plugins/bazaar/optionspage.cpp
+++ b/src/plugins/bazaar/optionspage.cpp
@@ -54,24 +54,24 @@ OptionsPageWidget::OptionsPageWidget(QWidget *parent) :
 
 BazaarSettings OptionsPageWidget::settings() const
 {
-    BazaarSettings rc;
-    rc.setBinary(m_ui.commandChooser->path());
-    rc.setUserName(m_ui.defaultUsernameLineEdit->text().trimmed());
-    rc.setEmail(m_ui.defaultEmailLineEdit->text().trimmed());
-    rc.setLogCount(m_ui.logEntriesCount->value());
-    rc.setTimeoutSeconds(m_ui.timeout->value());
-    rc.setPrompt(m_ui.promptOnSubmitCheckBox->isChecked());
-    return rc;
+    BazaarSettings s = BazaarPlugin::instance()->settings();
+    s.setValue(BazaarSettings::binaryPathKey, m_ui.commandChooser->path());
+    s.setValue(BazaarSettings::userNameKey, m_ui.defaultUsernameLineEdit->text().trimmed());
+    s.setValue(BazaarSettings::userEmailKey, m_ui.defaultEmailLineEdit->text().trimmed());
+    s.setValue(BazaarSettings::logCountKey, m_ui.logEntriesCount->value());
+    s.setValue(BazaarSettings::timeoutKey, m_ui.timeout->value());
+    s.setValue(BazaarSettings::promptOnSubmitKey, m_ui.promptOnSubmitCheckBox->isChecked());
+    return s;
 }
 
 void OptionsPageWidget::setSettings(const BazaarSettings &s)
 {
-    m_ui.commandChooser->setPath(s.binary());
-    m_ui.defaultUsernameLineEdit->setText(s.userName());
-    m_ui.defaultEmailLineEdit->setText(s.email());
-    m_ui.logEntriesCount->setValue(s.logCount());
-    m_ui.timeout->setValue(s.timeoutSeconds());
-    m_ui.promptOnSubmitCheckBox->setChecked(s.prompt());
+    m_ui.commandChooser->setPath(s.stringValue(BazaarSettings::binaryPathKey));
+    m_ui.defaultUsernameLineEdit->setText(s.stringValue(BazaarSettings::userNameKey));
+    m_ui.defaultEmailLineEdit->setText(s.stringValue(BazaarSettings::userEmailKey));
+    m_ui.logEntriesCount->setValue(s.intValue(BazaarSettings::logCountKey));
+    m_ui.timeout->setValue(s.intValue(BazaarSettings::timeoutKey));
+    m_ui.promptOnSubmitCheckBox->setChecked(s.boolValue(BazaarSettings::promptOnSubmitKey));
 }
 
 QString OptionsPageWidget::searchKeywords() const
diff --git a/src/plugins/mercurial/clonewizard.cpp b/src/plugins/mercurial/clonewizard.cpp
index f8c7212fa2..37a6f57230 100644
--- a/src/plugins/mercurial/clonewizard.cpp
+++ b/src/plugins/mercurial/clonewizard.cpp
@@ -86,13 +86,13 @@ QSharedPointer<VCSBase::AbstractCheckoutJob> CloneWizard::createJob(const QList<
 
     const MercurialSettings &settings = MercurialPlugin::instance()->settings();
 
-    QStringList args = settings.standardArguments();
     QString path = page->path();
     QString directory = page->directory();
 
+    QStringList args;
     args << QLatin1String("clone") << page->repository() << directory;
     *checkoutPath = path + QLatin1Char('/') + directory;
     VCSBase::ProcessCheckoutJob *job = new VCSBase::ProcessCheckoutJob;
-    job->addStep(settings.binary(), args, path);
+    job->addStep(settings.stringValue(MercurialSettings::binaryPathKey), args, path);
     return QSharedPointer<VCSBase::AbstractCheckoutJob>(job);
 }
diff --git a/src/plugins/mercurial/mercurialclient.cpp b/src/plugins/mercurial/mercurialclient.cpp
index d2c38a0527..16862444b4 100644
--- a/src/plugins/mercurial/mercurialclient.cpp
+++ b/src/plugins/mercurial/mercurialclient.cpp
@@ -423,9 +423,9 @@ public:
         VCSBase::VCSBaseEditorParameterWidget(parent), m_client(client), m_params(p)
     {
         mapSetting(addToggleButton(QLatin1String("-w"), tr("Ignore whitespace")),
-                   &client->settings()->diffIgnoreWhiteSpace);
+                   client->settings()->boolPointer(MercurialSettings::diffIgnoreWhiteSpaceKey));
         mapSetting(addToggleButton(QLatin1String("-B"), tr("Ignore blank lines")),
-                   &client->settings()->diffIgnoreBlankLines);
+                   client->settings()->boolPointer(MercurialSettings::diffIgnoreBlankLinesKey));
     }
 
     void executeCommand()
diff --git a/src/plugins/mercurial/mercurialcontrol.cpp b/src/plugins/mercurial/mercurialcontrol.cpp
index a38a819b83..1b83eb4b54 100644
--- a/src/plugins/mercurial/mercurialcontrol.cpp
+++ b/src/plugins/mercurial/mercurialcontrol.cpp
@@ -69,7 +69,7 @@ bool MercurialControl::managesDirectory(const QString &directory, QString *topLe
 
 bool MercurialControl::isConfigured() const
 {
-    const QString binary = mercurialClient->settings()->binary();
+    const QString binary = mercurialClient->settings()->stringValue(MercurialSettings::binaryPathKey);
     if (binary.isEmpty())
         return false;
     QFileInfo fi(binary);
diff --git a/src/plugins/mercurial/mercurialplugin.cpp b/src/plugins/mercurial/mercurialplugin.cpp
index 8c27aa914f..8d4cf91f65 100644
--- a/src/plugins/mercurial/mercurialplugin.cpp
+++ b/src/plugins/mercurial/mercurialplugin.cpp
@@ -203,11 +203,6 @@ void MercurialPlugin::setSettings(const MercurialSettings &settings)
     }
 }
 
-QStringList MercurialPlugin::standardArguments() const
-{
-    return mercurialSettings.standardArguments();
-}
-
 void MercurialPlugin::createMenu()
 {
     Core::Context context(Core::Constants::C_GLOBAL);
@@ -614,8 +609,9 @@ void MercurialPlugin::showCommitWidget(const QList<VCSBase::VCSBaseClient::Statu
 
     QString branch = m_client->branchQuerySync(m_submitRepository);
 
-    commitEditor->setFields(m_submitRepository, branch, mercurialSettings.userName(),
-                            mercurialSettings.email(), status);
+    commitEditor->setFields(m_submitRepository, branch,
+                            mercurialSettings.stringValue(MercurialSettings::userNameKey),
+                            mercurialSettings.stringValue(MercurialSettings::userEmailKey), status);
 
     commitEditor->registerActions(editorUndo, editorRedo, editorCommit, editorDiff);
     connect(commitEditor, SIGNAL(diffSelectedFiles(QStringList)),
@@ -646,11 +642,11 @@ bool MercurialPlugin::submitEditorAboutToClose(VCSBase::VCSBaseSubmitEditor *sub
     if (!editorFile || !commitEditor)
         return true;
 
-    bool dummyPrompt = mercurialSettings.prompt();
+    bool dummyPrompt = mercurialSettings.boolValue(MercurialSettings::promptOnSubmitKey);
     const VCSBase::VCSBaseSubmitEditor::PromptSubmitResult response =
             commitEditor->promptSubmit(tr("Close Commit Editor"), tr("Do you want to commit the changes?"),
                                        tr("Message check failed. Do you want to proceed?"),
-                                       &dummyPrompt, mercurialSettings.prompt());
+                                       &dummyPrompt, dummyPrompt);
 
     switch (response) {
     case VCSBase::VCSBaseSubmitEditor::SubmitCanceled:
diff --git a/src/plugins/mercurial/mercurialplugin.h b/src/plugins/mercurial/mercurialplugin.h
index d6193d8192..2e86c6daf1 100644
--- a/src/plugins/mercurial/mercurialplugin.h
+++ b/src/plugins/mercurial/mercurialplugin.h
@@ -91,8 +91,6 @@ public:
     static MercurialPlugin *instance() { return m_instance; }
     MercurialClient *client() const { return m_client; }
 
-    QStringList standardArguments() const;
-
     const MercurialSettings &settings() const;
     void setSettings(const MercurialSettings &settings);
 
diff --git a/src/plugins/mercurial/mercurialsettings.cpp b/src/plugins/mercurial/mercurialsettings.cpp
index a0643394c3..8db5f6f6ea 100644
--- a/src/plugins/mercurial/mercurialsettings.cpp
+++ b/src/plugins/mercurial/mercurialsettings.cpp
@@ -38,53 +38,16 @@
 namespace Mercurial {
 namespace Internal {
 
-    const QLatin1String diffIgnoreWhiteSpaceKey("diffIgnoreWhiteSpace");
-    const QLatin1String diffIgnoreBlankLinesKey("diffIgnoreBlankLines");
+    const QLatin1String MercurialSettings::diffIgnoreWhiteSpaceKey("diffIgnoreWhiteSpace");
+    const QLatin1String MercurialSettings::diffIgnoreBlankLinesKey("diffIgnoreBlankLines");
 
-    MercurialSettings::MercurialSettings() :
-        diffIgnoreWhiteSpace(false),
-        diffIgnoreBlankLines(false)
+    MercurialSettings::MercurialSettings()
     {
         setSettingsGroup(QLatin1String("Mercurial"));
-        setDefaultBinary(QLatin1String(Constants::MERCURIALDEFAULT));
+        // Override default binary path
+        declareKey(binaryPathKey, QLatin1String(Constants::MERCURIALDEFAULT));
+        declareKey(diffIgnoreWhiteSpaceKey, false);
+        declareKey(diffIgnoreBlankLinesKey, false);
     }
-
-    MercurialSettings& MercurialSettings::operator=(const MercurialSettings& other)
-    {
-        VCSBase::VCSBaseClientSettings::operator=(other);
-        if (this != &other) {
-            diffIgnoreWhiteSpace = other.diffIgnoreWhiteSpace;
-            diffIgnoreBlankLines = other.diffIgnoreBlankLines;
-        }
-        return *this;
-    }
-
-    void MercurialSettings::writeSettings(QSettings *settings) const
-    {
-        VCSBaseClientSettings::writeSettings(settings);
-        settings->beginGroup(this->settingsGroup());
-        settings->setValue(diffIgnoreWhiteSpaceKey, diffIgnoreWhiteSpace);
-        settings->setValue(diffIgnoreBlankLinesKey, diffIgnoreBlankLines);
-        settings->endGroup();
-    }
-
-    void MercurialSettings::readSettings(const QSettings *settings)
-    {
-        VCSBaseClientSettings::readSettings(settings);
-        const QString keyRoot = this->settingsGroup() + QLatin1Char('/');
-        diffIgnoreWhiteSpace = settings->value(keyRoot + diffIgnoreWhiteSpaceKey, false).toBool();
-        diffIgnoreBlankLines = settings->value(keyRoot + diffIgnoreBlankLinesKey, false).toBool();
-    }
-
-    bool MercurialSettings::equals(const VCSBaseClientSettings &rhs) const
-    {
-        const MercurialSettings *hgRhs = dynamic_cast<const MercurialSettings *>(&rhs);
-        if (hgRhs == 0)
-            return false;
-        return VCSBaseClientSettings::equals(rhs)
-                && diffIgnoreWhiteSpace == hgRhs->diffIgnoreWhiteSpace
-                && diffIgnoreBlankLines == hgRhs->diffIgnoreBlankLines;
-    }
-
 } // namespace Internal
 } // namespace Mercurial
diff --git a/src/plugins/mercurial/mercurialsettings.h b/src/plugins/mercurial/mercurialsettings.h
index 12d199838f..4eea636683 100644
--- a/src/plugins/mercurial/mercurialsettings.h
+++ b/src/plugins/mercurial/mercurialsettings.h
@@ -41,15 +41,10 @@ namespace Internal {
 class MercurialSettings : public VCSBase::VCSBaseClientSettings
 {
 public:
-    MercurialSettings();
-    MercurialSettings& operator=(const MercurialSettings& other);
-
-    virtual void writeSettings(QSettings *settings) const;
-    virtual void readSettings(const QSettings *settings);
-    virtual bool equals(const VCSBaseClientSettings &rhs) const;
+    static const QLatin1String diffIgnoreWhiteSpaceKey;
+    static const QLatin1String diffIgnoreBlankLinesKey;
 
-    bool diffIgnoreWhiteSpace;
-    bool diffIgnoreBlankLines;
+    MercurialSettings();
 };
 
 } // namespace Internal
diff --git a/src/plugins/mercurial/optionspage.cpp b/src/plugins/mercurial/optionspage.cpp
index b529c695e3..52cbf7ce08 100644
--- a/src/plugins/mercurial/optionspage.cpp
+++ b/src/plugins/mercurial/optionspage.cpp
@@ -53,24 +53,24 @@ OptionsPageWidget::OptionsPageWidget(QWidget *parent) :
 
 MercurialSettings OptionsPageWidget::settings() const
 {
-    MercurialSettings rc;
-    rc.setBinary(m_ui.commandChooser->path());
-    rc.setUserName(m_ui.defaultUsernameLineEdit->text().trimmed());
-    rc.setEmail(m_ui.defaultEmailLineEdit->text().trimmed());
-    rc.setLogCount(m_ui.logEntriesCount->value());
-    rc.setTimeoutSeconds(m_ui.timeout->value());
-    rc.setPrompt(m_ui.promptOnSubmitCheckBox->isChecked());
-    return rc;
+    MercurialSettings s = MercurialPlugin::instance()->settings();
+    s.setValue(MercurialSettings::binaryPathKey, m_ui.commandChooser->path());
+    s.setValue(MercurialSettings::userNameKey, m_ui.defaultUsernameLineEdit->text().trimmed());
+    s.setValue(MercurialSettings::userEmailKey, m_ui.defaultEmailLineEdit->text().trimmed());
+    s.setValue(MercurialSettings::logCountKey, m_ui.logEntriesCount->value());
+    s.setValue(MercurialSettings::timeoutKey, m_ui.timeout->value());
+    s.setValue(MercurialSettings::promptOnSubmitKey, m_ui.promptOnSubmitCheckBox->isChecked());
+    return s;
 }
 
 void OptionsPageWidget::setSettings(const MercurialSettings &s)
 {
-    m_ui.commandChooser->setPath(s.binary());
-    m_ui.defaultUsernameLineEdit->setText(s.userName());
-    m_ui.defaultEmailLineEdit->setText(s.email());
-    m_ui.logEntriesCount->setValue(s.logCount());
-    m_ui.timeout->setValue(s.timeoutSeconds());
-    m_ui.promptOnSubmitCheckBox->setChecked(s.prompt());
+    m_ui.commandChooser->setPath(s.stringValue(MercurialSettings::binaryPathKey));
+    m_ui.defaultUsernameLineEdit->setText(s.stringValue(MercurialSettings::userNameKey));
+    m_ui.defaultEmailLineEdit->setText(s.stringValue(MercurialSettings::userEmailKey));
+    m_ui.logEntriesCount->setValue(s.intValue(MercurialSettings::logCountKey));
+    m_ui.timeout->setValue(s.intValue(MercurialSettings::timeoutKey));
+    m_ui.promptOnSubmitCheckBox->setChecked(s.boolValue(MercurialSettings::promptOnSubmitKey));
 }
 
 QString OptionsPageWidget::searchKeywords() const
diff --git a/src/plugins/vcsbase/vcsbaseclient.cpp b/src/plugins/vcsbase/vcsbaseclient.cpp
index f63b13d288..803a87ddbc 100644
--- a/src/plugins/vcsbase/vcsbaseclient.cpp
+++ b/src/plugins/vcsbase/vcsbaseclient.cpp
@@ -35,8 +35,6 @@
 #include "vcsbaseclientsettings.h"
 #include "vcsbaseeditorparameterwidget.h"
 
-#include <QtDebug>
-
 #include <coreplugin/icore.h>
 #include <coreplugin/editormanager/editormanager.h>
 #include <coreplugin/vcsmanager.h>
@@ -88,6 +86,8 @@ public:
     void annotateRevision(QString source, QString change, int lineNumber);
     void saveSettings();
 
+    void updateJobRunnerSettings();
+
     VCSJobRunner *m_jobManager;
     Core::ICore *m_core;
     VCSBaseClientSettings *m_clientSettings;
@@ -132,6 +132,14 @@ void VCSBaseClientPrivate::saveSettings()
     m_clientSettings->writeSettings(m_core->settings());
 }
 
+void VCSBaseClientPrivate::updateJobRunnerSettings()
+{
+    if (m_jobManager && m_clientSettings) {
+        m_jobManager->setBinary(m_clientSettings->stringValue(VCSBaseClientSettings::binaryPathKey));
+        m_jobManager->setTimeoutMs(m_clientSettings->intValue(VCSBaseClientSettings::timeoutKey) * 1000);
+    }
+}
+
 VCSBaseClient::StatusItem::StatusItem()
 {
 }
@@ -257,13 +265,12 @@ bool VCSBaseClient::vcsFullySynchronousExec(const QString &workingDir,
         vcsProcess.setWorkingDirectory(workingDir);
     VCSJobRunner::setProcessEnvironment(&vcsProcess);
 
-    const QString binary = settings()->binary();
-    const QStringList arguments = settings()->standardArguments() + args;
+    const QString binary = settings()->stringValue(VCSBaseClientSettings::binaryPathKey);
 
     VCSBase::VCSBaseOutputWindow *outputWindow = VCSBase::VCSBaseOutputWindow::instance();
     outputWindow->appendCommand(workingDir, binary, args);
 
-    vcsProcess.start(binary, arguments);
+    vcsProcess.start(binary, args);
 
     if (!vcsProcess.waitForStarted()) {
         outputWindow->appendError(VCSJobRunner::msgStartFailed(binary, vcsProcess.errorString()));
@@ -273,10 +280,11 @@ bool VCSBaseClient::vcsFullySynchronousExec(const QString &workingDir,
     vcsProcess.closeWriteChannel();
 
     QByteArray stdErr;
-    if (!Utils::SynchronousProcess::readDataFromProcess(vcsProcess, settings()->timeoutMilliSeconds(),
+    const int timeoutSec = settings()->intValue(VCSBaseClientSettings::timeoutKey);
+    if (!Utils::SynchronousProcess::readDataFromProcess(vcsProcess, timeoutSec * 1000,
                                                         output, &stdErr, true)) {
         Utils::SynchronousProcess::stopProcess(vcsProcess);
-        outputWindow->appendError(VCSJobRunner::msgTimeout(binary, settings()->timeoutSeconds()));
+        outputWindow->appendError(VCSJobRunner::msgTimeout(binary, timeoutSec));
         return false;
     }
     if (!stdErr.isEmpty())
@@ -291,11 +299,10 @@ Utils::SynchronousProcessResponse VCSBaseClient::vcsSynchronousExec(
     unsigned flags,
     QTextCodec *outputCodec)
 {
-    const QString binary = settings()->binary();
-    const QStringList arguments = settings()->standardArguments() + args;
-    return VCSBase::VCSBasePlugin::runVCS(workingDirectory, binary, arguments,
-                                          settings()->timeoutMilliSeconds(),
-                                          flags, outputCodec);
+    const QString binary = settings()->stringValue(VCSBaseClientSettings::binaryPathKey);
+    const int timeoutSec = settings()->intValue(VCSBaseClientSettings::timeoutKey);
+    return VCSBase::VCSBasePlugin::runVCS(workingDirectory, binary, args,
+                                          timeoutSec * 1000, flags, outputCodec);
 }
 
 void VCSBaseClient::annotate(const QString &workingDir, const QString &file,
@@ -509,9 +516,7 @@ VCSBaseClientSettings *VCSBaseClient::settings() const
 void VCSBaseClient::handleSettingsChanged()
 {
     if (d->m_jobManager) {
-        d->m_jobManager->setSettings(settings()->binary(),
-                                     settings()->standardArguments(),
-                                     settings()->timeoutMilliSeconds());
+        d->updateJobRunnerSettings();
         d->m_jobManager->restart();
     }
 }
@@ -538,7 +543,8 @@ VCSBaseEditorParameterWidget *VCSBaseClient::createLogEditor(const QString &work
 
 QString VCSBaseClient::vcsEditorTitle(const QString &vcsCmd, const QString &sourceId) const
 {
-    return QFileInfo(settings()->binary()).baseName() +
+    const QString binary = settings()->stringValue(VCSBaseClientSettings::binaryPathKey);
+    return QFileInfo(binary).baseName() +
             QLatin1Char(' ') + vcsCmd + QLatin1Char(' ') +
             QFileInfo(sourceId).fileName();
 }
@@ -583,9 +589,7 @@ void VCSBaseClient::enqueueJob(const QSharedPointer<VCSJob> &job)
 {
     if (!d->m_jobManager) {
         d->m_jobManager = new VCSJobRunner();
-        d->m_jobManager->setSettings(settings()->binary(),
-                                     settings()->standardArguments(),
-                                     settings()->timeoutMilliSeconds());
+        d->updateJobRunnerSettings();
         d->m_jobManager->start();
     }
     d->m_jobManager->enqueueJob(job);
diff --git a/src/plugins/vcsbase/vcsbaseclientsettings.cpp b/src/plugins/vcsbase/vcsbaseclientsettings.cpp
index df83a1b590..42c810c76f 100644
--- a/src/plugins/vcsbase/vcsbaseclientsettings.cpp
+++ b/src/plugins/vcsbase/vcsbaseclientsettings.cpp
@@ -34,9 +34,147 @@
 
 #include <QtCore/QSettings>
 
-using namespace VCSBase;
+namespace {
 
-enum { timeOutDefaultSeconds = 30 };
+class SettingValue
+{
+public:
+    union Composite
+    {
+        QString *strPtr; // Union can't store class objects ...
+        int intValue;
+        bool boolValue;
+    };
+
+    SettingValue() :
+        m_type(QVariant::Invalid)
+    {
+    }
+
+    explicit SettingValue(const QVariant &v) :
+        m_type(v.type())
+    {
+        switch (v.type()) {
+        case QVariant::UInt:
+            m_type = QVariant::Int;
+        case QVariant::Int:
+            m_comp.intValue = v.toInt();
+            break;
+        case QVariant::Bool:
+            m_comp.boolValue = v.toBool();
+            break;
+        case QVariant::String:
+            m_comp.strPtr = new QString(v.toString());
+            break;
+        default:
+            m_type = QVariant::Invalid;
+            break;
+        }
+    }
+
+    SettingValue(const SettingValue &other) :
+        m_comp(other.m_comp),
+        m_type(other.type())
+    {
+        copyInternalString(other);
+    }
+
+    ~SettingValue()
+    {
+        deleteInternalString();
+    }
+
+    SettingValue &operator=(const SettingValue &other)
+    {
+        if (this != &other) {
+            deleteInternalString();
+            m_type = other.type();
+            m_comp = other.m_comp;
+            copyInternalString(other);
+        }
+        return *this;
+    }
+
+    QString stringValue(const QString &defaultString = QString()) const
+    {
+        if (type() == QVariant::String && m_comp.strPtr != 0)
+            return *(m_comp.strPtr);
+        return defaultString;
+    }
+
+    QVariant::Type type() const
+    {
+        return m_type;
+    }
+
+    static bool isUsableVariantType(QVariant::Type varType)
+    {
+        return varType == QVariant::UInt || varType == QVariant::Int ||
+                varType == QVariant::Bool || varType == QVariant::String;
+    }
+
+    Composite m_comp;
+
+private:
+    void deleteInternalString()
+    {
+        if (m_type == QVariant::String && m_comp.strPtr != 0) {
+            delete m_comp.strPtr;
+            m_comp.strPtr = 0;
+        }
+    }
+
+    void copyInternalString(const SettingValue &other)
+    {
+        if (type() == QVariant::String) {
+            const QString *otherString = other.m_comp.strPtr;
+            m_comp.strPtr = new QString(otherString != 0 ? *otherString : QString());
+        }
+    }
+
+    QVariant::Type m_type;
+};
+
+bool operator==(const SettingValue &lhs, const SettingValue &rhs)
+{
+    if (lhs.type() == rhs.type()) {
+        switch (lhs.type()) {
+        case QVariant::Int:
+            return lhs.m_comp.intValue == rhs.m_comp.intValue;
+        case QVariant::Bool:
+            return lhs.m_comp.boolValue == rhs.m_comp.boolValue;
+        case QVariant::String:
+            return lhs.stringValue() == rhs.stringValue();
+        default:
+            return false;
+        }
+    }
+    return false;
+}
+
+} // Anonymous namespace
+
+namespace VCSBase {
+
+class VCSBaseClientSettingsPrivate : public QSharedData
+{
+public:
+    VCSBaseClientSettingsPrivate()
+    {
+    }
+
+    VCSBaseClientSettingsPrivate(const VCSBaseClientSettingsPrivate &other) :
+        QSharedData(other),
+        m_valueHash(other.m_valueHash),
+        m_defaultValueHash(other.m_defaultValueHash),
+        m_settingsGroup(other.m_settingsGroup)
+    {
+    }
+
+    QHash<QString, SettingValue> m_valueHash;
+    QVariantHash m_defaultValueHash;
+    QString m_settingsGroup;
+};
 
 /*!
     \class VCSBase::VCSBaseClientSettings
@@ -46,137 +184,182 @@ enum { timeOutDefaultSeconds = 30 };
     \sa VCSBase::VCSBaseClient
 */
 
+const QLatin1String VCSBaseClientSettings::binaryPathKey("BinaryPath");
+const QLatin1String VCSBaseClientSettings::userNameKey("Username");
+const QLatin1String VCSBaseClientSettings::userEmailKey("UserEmail");
+const QLatin1String VCSBaseClientSettings::logCountKey("LogCount");
+const QLatin1String VCSBaseClientSettings::promptOnSubmitKey("PromptOnSubmit");
+const QLatin1String VCSBaseClientSettings::timeoutKey("Timeout");
+
 VCSBaseClientSettings::VCSBaseClientSettings() :
-    m_logCount(0),
-    m_prompt(true),
-    m_timeoutSeconds(timeOutDefaultSeconds)
+    d(new VCSBaseClientSettingsPrivate)
 {
+    declareKey(binaryPathKey, QLatin1String(""));
+    declareKey(userNameKey, QLatin1String(""));
+    declareKey(userEmailKey, QLatin1String(""));
+    declareKey(logCountKey, 100);
+    declareKey(promptOnSubmitKey, true);
+    declareKey(timeoutKey, 30);
 }
 
-VCSBaseClientSettings::~VCSBaseClientSettings()
-{ }
-
-QString VCSBaseClientSettings::binary() const
+VCSBaseClientSettings::VCSBaseClientSettings(const VCSBaseClientSettings &other) :
+    d(other.d)
 {
-    if (m_binary.isEmpty())
-        return defaultBinary(); // Fallback binary if not specified
-    return m_binary;
 }
 
-void VCSBaseClientSettings::setBinary(const QString &b)
+VCSBaseClientSettings &VCSBaseClientSettings::operator=(const VCSBaseClientSettings &other)
 {
-    m_binary = b;
+    if (this != &other)
+      d = other.d;
+    return *this;
 }
 
-QStringList VCSBaseClientSettings::standardArguments() const
+VCSBaseClientSettings::~VCSBaseClientSettings()
 {
-    return m_standardArguments;
 }
 
-QString VCSBaseClientSettings::userName() const
+void VCSBaseClientSettings::writeSettings(QSettings *settings) const
 {
-    return m_user;
+    settings->beginGroup(settingsGroup());
+    foreach (const QString &key, keys())
+        settings->setValue(key, value(key));
+    settings->endGroup();
 }
 
-void VCSBaseClientSettings::setUserName(const QString &u)
+void VCSBaseClientSettings::readSettings(const QSettings *settings)
 {
-    m_user = u;
+    const QString keyRoot = settingsGroup() + QLatin1Char('/');
+    foreach (const QString &key, keys()) {
+        const QVariant value = settings->value(keyRoot + key, keyDefaultValue(key));
+        // For some reason QSettings always return QVariant(QString) when the
+        // key exists. The type is explicited to avoid wrong conversions
+        switch (valueType(key)) {
+        case QVariant::Int:
+            setValue(key, value.toInt());
+            break;
+        case QVariant::Bool:
+            setValue(key, value.toBool());
+            break;
+        case QVariant::String:
+            setValue(key, value.toString());
+            break;
+        default:
+            break;
+        }
+    }
 }
 
-QString VCSBaseClientSettings::email() const
+bool VCSBaseClientSettings::equals(const VCSBaseClientSettings &rhs) const
 {
-    return m_mail;
+    if (this == &rhs)
+        return true;
+    return d->m_valueHash == rhs.d->m_valueHash;
 }
 
-void VCSBaseClientSettings::setEmail(const QString &m)
+QStringList VCSBaseClientSettings::keys() const
 {
-    m_mail = m;
+    return d->m_valueHash.keys();
 }
 
-int VCSBaseClientSettings::logCount() const
+bool VCSBaseClientSettings::hasKey(const QString &key) const
 {
-    return m_logCount;
+    return d->m_valueHash.contains(key);
 }
 
-void VCSBaseClientSettings::setLogCount(int l)
+int *VCSBaseClientSettings::intPointer(const QString &key)
 {
-    m_logCount = l;
+    if (hasKey(key))
+        return &(d->m_valueHash[key].m_comp.intValue);
+    return 0;
 }
 
-bool VCSBaseClientSettings::prompt() const
+bool *VCSBaseClientSettings::boolPointer(const QString &key)
 {
-    return m_prompt;
+    if (hasKey(key))
+        return &(d->m_valueHash[key].m_comp.boolValue);
+    return 0;
 }
 
-void VCSBaseClientSettings::setPrompt(bool b)
+QString *VCSBaseClientSettings::stringPointer(const QString &key)
 {
-    m_prompt = b;
+    if (hasKey(key))
+        return d->m_valueHash[key].m_comp.strPtr;
+    return 0;
 }
 
-int VCSBaseClientSettings::timeoutMilliSeconds() const
+int VCSBaseClientSettings::intValue(const QString &key, int defaultValue) const
 {
-    //return timeout is in Ms
-    return m_timeoutSeconds * 1000;
+    if (hasKey(key))
+        return d->m_valueHash[key].m_comp.intValue;
+    return defaultValue;
 }
 
-int VCSBaseClientSettings::timeoutSeconds() const
+bool VCSBaseClientSettings::boolValue(const QString &key, bool defaultValue) const
 {
-    //return timeout in seconds (as the user specifies on the options page
-    return m_timeoutSeconds;
+    if (hasKey(key))
+        return d->m_valueHash[key].m_comp.boolValue;
+    return defaultValue;
 }
 
-void VCSBaseClientSettings::setTimeoutSeconds(int s)
+QString VCSBaseClientSettings::stringValue(const QString &key, const QString &defaultValue) const
 {
-    m_timeoutSeconds = s;
+    if (hasKey(key))
+        return d->m_valueHash[key].stringValue(defaultValue);
+    return defaultValue;
 }
 
-QString VCSBaseClientSettings::settingsGroup() const
+QVariant VCSBaseClientSettings::value(const QString &key) const
 {
-    return m_settingsGroup;
+    switch (valueType(key)) {
+    case QVariant::Int:
+        return intValue(key);
+    case QVariant::Bool:
+        return boolValue(key);
+    case QVariant::String:
+        return stringValue(key);
+    case QVariant::Invalid:
+        return QVariant();
+    default:
+        return QVariant();
+    }
 }
 
-void VCSBaseClientSettings::setSettingsGroup(const QString &group)
+void VCSBaseClientSettings::setValue(const QString &key, const QVariant &v)
 {
-    m_settingsGroup = group;
+    if (SettingValue::isUsableVariantType(valueType(key)))
+        d->m_valueHash.insert(key, SettingValue(v));
 }
 
-void VCSBaseClientSettings::writeSettings(QSettings *settings) const
+QVariant::Type VCSBaseClientSettings::valueType(const QString &key) const
 {
-    settings->beginGroup(settingsGroup());
-    settings->setValue(QLatin1String("VCS_Path"), m_binary);
-    settings->setValue(QLatin1String("VCS_Username"), m_user);
-    settings->setValue(QLatin1String("VCS_Email"), m_mail);
-    settings->setValue(QLatin1String("VCS_LogCount"), m_logCount);
-    settings->setValue(QLatin1String("VCS_PromptOnSubmit"), m_prompt);
-    settings->setValue(QLatin1String("VCS_Timeout"), m_timeoutSeconds);
-    settings->endGroup();
+    if (hasKey(key))
+        return d->m_valueHash[key].type();
+    return QVariant::Invalid;
 }
 
-void VCSBaseClientSettings::readSettings(const QSettings *settings)
+QString VCSBaseClientSettings::settingsGroup() const
 {
-    const QString keyRoot = settingsGroup() + QLatin1Char('/');
-    m_binary = settings->value(keyRoot + QLatin1String("VCS_Path"), defaultBinary()).toString();
-    m_user = settings->value(keyRoot + QLatin1String("VCS_Username"), QString()).toString();
-    m_mail = settings->value(keyRoot + QLatin1String("VCS_Email"), QString()).toString();
-    m_logCount = settings->value(keyRoot + QLatin1String("VCS_LogCount"), QString()).toInt();
-    m_prompt = settings->value(keyRoot + QLatin1String("VCS_PromptOnSubmit"), QString()).toBool();
-    m_timeoutSeconds = settings->value(keyRoot + QLatin1String("VCS_Timeout"), timeOutDefaultSeconds).toInt();
+    return d->m_settingsGroup;
 }
 
-bool VCSBaseClientSettings::equals(const VCSBaseClientSettings &rhs) const
+void VCSBaseClientSettings::setSettingsGroup(const QString &group)
 {
-    return m_binary == rhs.m_binary && m_standardArguments == rhs.m_standardArguments
-            && m_user == rhs.m_user && m_mail == rhs.m_mail
-            && m_logCount == rhs.m_logCount && m_prompt == rhs.m_prompt
-            && m_timeoutSeconds == rhs.m_timeoutSeconds;
+    d->m_settingsGroup = group;
 }
 
-QString VCSBaseClientSettings::defaultBinary() const
+void VCSBaseClientSettings::declareKey(const QString &key, const QVariant &defaultValue)
 {
-    return m_defaultBinary;
+    if (SettingValue::isUsableVariantType(defaultValue.type())) {
+        d->m_valueHash.insert(key, SettingValue(defaultValue));
+        d->m_defaultValueHash.insert(key, defaultValue);
+    }
 }
 
-void VCSBaseClientSettings::setDefaultBinary(const QString &bin)
+QVariant VCSBaseClientSettings::keyDefaultValue(const QString &key) const
 {
-    m_defaultBinary = bin;
+    if (d->m_defaultValueHash.contains(key))
+        return d->m_defaultValueHash.value(key);
+    return QVariant(valueType(key));
 }
+
+} // namespace VCSBase
diff --git a/src/plugins/vcsbase/vcsbaseclientsettings.h b/src/plugins/vcsbase/vcsbaseclientsettings.h
index 9553b009e3..989a5a8454 100644
--- a/src/plugins/vcsbase/vcsbaseclientsettings.h
+++ b/src/plugins/vcsbase/vcsbaseclientsettings.h
@@ -36,6 +36,8 @@
 #include "vcsbase_global.h"
 #include <QtCore/QString>
 #include <QtCore/QStringList>
+#include <QtCore/QVariant>
+#include <QtCore/QSharedDataPointer>
 
 QT_BEGIN_NAMESPACE
 class QSettings;
@@ -43,56 +45,55 @@ QT_END_NAMESPACE
 
 namespace VCSBase {
 
+class VCSBaseClientSettingsPrivate;
+
 class VCSBASE_EXPORT VCSBaseClientSettings
 {
 public:
+    static const QLatin1String binaryPathKey;
+    static const QLatin1String userNameKey;
+    static const QLatin1String userEmailKey;
+    static const QLatin1String logCountKey;
+    static const QLatin1String promptOnSubmitKey;
+    static const QLatin1String timeoutKey; // Seconds
+
     VCSBaseClientSettings();
+    VCSBaseClientSettings(const VCSBaseClientSettings &other);
+    VCSBaseClientSettings &operator=(const VCSBaseClientSettings &other);
     virtual ~VCSBaseClientSettings();
 
-    QString binary() const;
-    void setBinary(const QString &);
+    void writeSettings(QSettings *settings) const;
+    void readSettings(const QSettings *settings);
 
-    // Calculated
-    QStringList standardArguments() const;
+    bool equals(const VCSBaseClientSettings &rhs) const;
 
-    QString userName() const;
-    void setUserName(const QString &);
+    QStringList keys() const;
+    bool hasKey(const QString &key) const;
 
-    QString email() const;
-    void setEmail(const QString &);
+    int *intPointer(const QString &key);
+    int intValue(const QString &key, int defaultValue = 0) const;
 
-    int logCount() const;
-    void setLogCount(int l);
+    bool *boolPointer(const QString &key);
+    bool boolValue(const QString &key, bool defaultValue = false) const;
 
-    bool prompt() const;
-    void setPrompt(bool b);
+    QString *stringPointer(const QString &key);
+    QString stringValue(const QString &key, const QString &defaultValue = QString()) const;
 
-    int timeoutMilliSeconds() const;
-    int timeoutSeconds() const;
-    void setTimeoutSeconds(int s);
+    QVariant value(const QString &key) const;
+    void setValue(const QString &key, const QVariant &v);
+    QVariant::Type valueType(const QString &key) const;
 
+protected:
     QString settingsGroup() const;
     void setSettingsGroup(const QString &group);
 
-    virtual void writeSettings(QSettings *settings) const;
-    virtual void readSettings(const QSettings *settings);
-
-    virtual bool equals(const VCSBaseClientSettings &rhs) const;
-
-protected:
-    QString defaultBinary() const;
-    void setDefaultBinary(const QString &bin);
+    void declareKey(const QString &key, const QVariant &defaultValue);
+    QVariant keyDefaultValue(const QString &key) const;
 
 private:
-    QString m_binary;
-    QString m_defaultBinary;
-    QStringList m_standardArguments;
-    QString m_user;
-    QString m_mail;
-    int m_logCount;
-    bool m_prompt;
-    int m_timeoutSeconds;
-    QString m_settingsGroup;
+    friend bool equals(const VCSBaseClientSettings &rhs);
+    friend class VCSBaseClientSettingsPrivate;
+    QSharedDataPointer<VCSBaseClientSettingsPrivate> d;
 };
 
 inline bool operator==(const VCSBaseClientSettings &s1, const VCSBaseClientSettings &s2)
diff --git a/src/plugins/vcsbase/vcsjobrunner.cpp b/src/plugins/vcsbase/vcsjobrunner.cpp
index 70e2ee0b2d..38cfd01287 100644
--- a/src/plugins/vcsbase/vcsjobrunner.cpp
+++ b/src/plugins/vcsbase/vcsjobrunner.cpp
@@ -182,12 +182,11 @@ public:
     QWaitCondition m_waiter;
     bool m_keepRunning;
     QString m_binary;
-    QStringList m_standardArguments;
-    int m_timeoutMS;
+    int m_timeoutMs;
 };
 
 VCSJobRunnerPrivate::VCSJobRunnerPrivate() :
-    m_keepRunning(true), m_timeoutMS(30000)
+    m_keepRunning(true), m_timeoutMs(30000)
 {
 }
 
@@ -278,13 +277,24 @@ void VCSJobRunner::setProcessEnvironment(QProcess *p)
     p->setProcessEnvironment(env);
 }
 
-void VCSJobRunner::setSettings(const QString &bin,
-                               const QStringList &stdArgs,
-                               int timeoutMsec)
+const QString &VCSJobRunner::binary() const
+{
+    return d->m_binary;
+}
+
+void VCSJobRunner::setBinary(const QString &bin)
 {
     d->m_binary = bin;
-    d->m_standardArguments = stdArgs;
-    d->m_timeoutMS = timeoutMsec;
+}
+
+int VCSJobRunner::timeoutMs() const
+{
+    return d->m_timeoutMs;
+}
+
+void VCSJobRunner::setTimeoutMs(int msec)
+{
+    d->m_timeoutMs = msec;
 }
 
 void VCSJobRunner::task(const QSharedPointer<VCSJob> &job)
@@ -319,8 +329,14 @@ void VCSJobRunner::task(const QSharedPointer<VCSJob> &job)
     DisconnectSignalHelper autoDisconnectOutputSig(this, SIGNAL(output(QByteArray)));
     Q_UNUSED(autoDisconnectOutputSig);
 
-    const QStringList args = d->m_standardArguments + taskData->arguments();
-    emit commandStarted(VCSBase::VCSBaseOutputWindow::msgExecutionLogEntry(taskData->workingDirectory(), d->m_binary, args));
+    // Check that the binary path is not empty
+    if (binary().trimmed().isEmpty()) {
+        emit error(tr("Unable to start process, binary is empty"));
+        return;
+    }
+
+    const QStringList args = taskData->arguments();
+    emit commandStarted(VCSBase::VCSBaseOutputWindow::msgExecutionLogEntry(taskData->workingDirectory(), binary(), args));
     //infom the user of what we are going to try and perform
 
     if (Constants::Internal::debug)
@@ -336,10 +352,10 @@ void VCSJobRunner::task(const QSharedPointer<VCSJob> &job)
     vcsProcess->setWorkingDirectory(taskData->workingDirectory());
     VCSJobRunner::setProcessEnvironment(vcsProcess.data());
 
-    vcsProcess->start(d->m_binary, args);
+    vcsProcess->start(binary(), args);
 
     if (!vcsProcess->waitForStarted()) {
-        emit error(msgStartFailed(d->m_binary, vcsProcess->errorString()));
+        emit error(msgStartFailed(binary(), vcsProcess->errorString()));
         return;
     }
 
@@ -348,9 +364,9 @@ void VCSJobRunner::task(const QSharedPointer<VCSJob> &job)
     QByteArray stdOutput;
     QByteArray stdErr;
 
-    if (!Utils::SynchronousProcess::readDataFromProcess(*vcsProcess, d->m_timeoutMS, &stdOutput, &stdErr, false)) {
+    if (!Utils::SynchronousProcess::readDataFromProcess(*vcsProcess, timeoutMs(), &stdOutput, &stdErr, false)) {
         Utils::SynchronousProcess::stopProcess(*vcsProcess);
-        emit error(msgTimeout(d->m_binary, d->m_timeoutMS / 1000));
+        emit error(msgTimeout(binary(), timeoutMs() / 1000));
         return;
     }
 
diff --git a/src/plugins/vcsbase/vcsjobrunner.h b/src/plugins/vcsbase/vcsjobrunner.h
index edc27f032e..8186a0fbad 100644
--- a/src/plugins/vcsbase/vcsjobrunner.h
+++ b/src/plugins/vcsbase/vcsjobrunner.h
@@ -109,7 +109,11 @@ public:
     // Set environment for a VCS process to run in locale "C"
     static void setProcessEnvironment(QProcess *p);
 
-    void setSettings(const QString &bin, const QStringList &stdArgs, int timeoutMsec);
+    const QString &binary() const;
+    void setBinary(const QString &bin);
+
+    int timeoutMs() const;
+    void setTimeoutMs(int msec);
 
 protected:
     void run();