subversionplugin.cpp 40.7 KB
Newer Older
1
/**************************************************************************
con's avatar
con committed
2 3 4
**
** This file is part of Qt Creator
**
5
** Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
con's avatar
con committed
6
**
7
** Contact: Nokia Corporation (qt-info@nokia.com)
con's avatar
con committed
8
**
9
** Commercial Usage
10
**
11 12 13 14
** Licensees holding valid Qt Commercial licenses may use this file in
** accordance with the Qt Commercial License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Nokia.
15
**
16
** GNU Lesser General Public License Usage
17
**
18 19 20 21 22 23
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
24
**
25
** If you are unsure which license is appropriate for your use, please
hjk's avatar
hjk committed
26
** contact the sales department at http://qt.nokia.com/contact.
con's avatar
con committed
27
**
28
**************************************************************************/
hjk's avatar
hjk committed
29

con's avatar
con committed
30 31 32 33 34 35 36 37
#include "subversionplugin.h"

#include "settingspage.h"
#include "subversioneditor.h"

#include "subversionsubmiteditor.h"
#include "subversionconstants.h"
#include "subversioncontrol.h"
38
#include "checkoutwizard.h"
con's avatar
con committed
39 40 41 42

#include <vcsbase/basevcseditorfactory.h>
#include <vcsbase/vcsbaseeditor.h>
#include <vcsbase/basevcssubmiteditorfactory.h>
43
#include <vcsbase/vcsbaseoutputwindow.h>
con's avatar
con committed
44
#include <utils/synchronousprocess.h>
45
#include <utils/parameteraction.h>
con's avatar
con committed
46 47 48 49 50 51 52

#include <coreplugin/icore.h>
#include <coreplugin/coreconstants.h>
#include <coreplugin/filemanager.h>
#include <coreplugin/messagemanager.h>
#include <coreplugin/mimedatabase.h>
#include <coreplugin/uniqueidmanager.h>
53
#include <coreplugin/actionmanager/actionmanager.h>
con's avatar
con committed
54
#include <coreplugin/editormanager/editormanager.h>
hjk's avatar
hjk committed
55
#include <utils/qtcassert.h>
con's avatar
con committed
56 57

#include <QtCore/QDebug>
58
#include <QtCore/QDir>
con's avatar
con committed
59 60
#include <QtCore/QFileInfo>
#include <QtCore/QTemporaryFile>
61 62
#include <QtCore/QTextCodec>
#include <QtCore/QtPlugin>
con's avatar
con committed
63
#include <QtGui/QAction>
64 65
#include <QtGui/QFileDialog>
#include <QtGui/QMainWindow>
con's avatar
con committed
66 67
#include <QtGui/QMenu>
#include <QtGui/QMessageBox>
68 69 70
#include <QtGui/QInputDialog>

#include <limits.h>
con's avatar
con committed
71 72 73 74 75 76 77 78

using namespace Subversion::Internal;

// Timeout for normal output commands
enum { subversionShortTimeOut = 10000 };
// Timeout for submit, update
enum { subversionLongTimeOut = 120000 };

79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
static const char * const CMD_ID_SUBVERSION_MENU    = "Subversion.Menu";
static const char * const CMD_ID_ADD                = "Subversion.Add";
static const char * const CMD_ID_DELETE_FILE        = "Subversion.Delete";
static const char * const CMD_ID_REVERT             = "Subversion.Revert";
static const char * const CMD_ID_SEPARATOR0         = "Subversion.Separator0";
static const char * const CMD_ID_DIFF_PROJECT       = "Subversion.DiffAll";
static const char * const CMD_ID_DIFF_CURRENT       = "Subversion.DiffCurrent";
static const char * const CMD_ID_SEPARATOR1         = "Subversion.Separator1";
static const char * const CMD_ID_COMMIT_ALL         = "Subversion.CommitAll";
static const char * const CMD_ID_COMMIT_CURRENT     = "Subversion.CommitCurrent";
static const char * const CMD_ID_SEPARATOR2         = "Subversion.Separator2";
static const char * const CMD_ID_FILELOG_CURRENT    = "Subversion.FilelogCurrent";
static const char * const CMD_ID_ANNOTATE_CURRENT   = "Subversion.AnnotateCurrent";
static const char * const CMD_ID_SEPARATOR3         = "Subversion.Separator3";
static const char * const CMD_ID_STATUS             = "Subversion.Status";
static const char * const CMD_ID_UPDATE             = "Subversion.Update";
static const char * const CMD_ID_DESCRIBE           = "Subversion.Describe";
con's avatar
con committed
96

97 98
static const char *nonInteractiveOptionC = "--non-interactive";

con's avatar
con committed
99 100 101
static const VCSBase::VCSBaseEditorParameters editorParameters[] = {
{
    VCSBase::RegularCommandOutput,
102 103
    "Subversion Command Log Editor", // kind
    "Subversion Command Log Editor", // context
con's avatar
con committed
104 105 106
    "application/vnd.nokia.text.scs_svn_commandlog",
    "scslog"},
{   VCSBase::LogOutput,
107 108
    "Subversion File Log Editor",   // kind
    "Subversion File Log Editor",   // context
con's avatar
con committed
109 110 111
    "application/vnd.nokia.text.scs_svn_filelog",
    "scsfilelog"},
{    VCSBase::AnnotateOutput,
112 113
    "Subversion Annotation Editor",  // kind
    "Subversion Annotation Editor",  // context
con's avatar
con committed
114 115 116
    "application/vnd.nokia.text.scs_svn_annotation",
    "scsannotate"},
{   VCSBase::DiffOutput,
117 118
    "Subversion Diff Editor",  // kind
    "Subversion Diff Editor",  // context
con's avatar
con committed
119 120 121 122 123 124 125 126 127 128 129 130 131 132 133
    "text/x-patch","diff"}
};

// Utility to find a parameter set by type
static inline const VCSBase::VCSBaseEditorParameters *findType(int ie)
{
    const VCSBase::EditorContentType et = static_cast<VCSBase::EditorContentType>(ie);
    return  VCSBase::VCSBaseEditor::findType(editorParameters, sizeof(editorParameters)/sizeof(VCSBase::VCSBaseEditorParameters), et);
}

static inline QString debugCodec(const QTextCodec *c)
{
    return c ? QString::fromAscii(c->name()) : QString::fromAscii("Null codec");
}

hjk's avatar
hjk committed
134
Core::IEditor* locateEditor(const char *property, const QString &entry)
con's avatar
con committed
135
{
136
    foreach (Core::IEditor *ed, Core::EditorManager::instance()->openedEditors())
con's avatar
con committed
137 138 139 140 141
        if (ed->property(property).toString() == entry)
            return ed;
    return 0;
}

142 143 144 145 146 147 148 149 150 151 152 153 154 155
// Parse "svn status" output for added/modified/deleted files
// "M<7blanks>file"
typedef QList<SubversionSubmitEditor::StatusFilePair> StatusList;

StatusList parseStatusOutput(const QString &output)
{
    StatusList changeSet;
    const QString newLine = QString(QLatin1Char('\n'));
    const QStringList list = output.split(newLine, QString::SkipEmptyParts);
    foreach (const QString &l, list) {
        const QString line =l.trimmed();
        if (line.size() > 8) {
            const QChar state = line.at(0);
            if (state == QLatin1Char('A') || state == QLatin1Char('D') || state == QLatin1Char('M')) {
156 157
                const QString fileName = line.mid(7); // Column 8 starting from svn 1.6
                changeSet.push_back(SubversionSubmitEditor::StatusFilePair(QString(state), fileName.trimmed()));
158 159 160 161 162 163 164
            }

        }
    }
    return changeSet;
}

165 166 167 168 169 170 171 172 173 174 175
// Return a list of names for the internal svn directories
static inline QStringList svnDirectories()
{
    QStringList rc(QLatin1String(".svn"));
#ifdef Q_OS_WIN
    // Option on Windows systems to avoid hassle with some IDEs
    rc.push_back(QLatin1String("_svn"));
#endif
    return rc;
}

con's avatar
con committed
176 177 178 179
// ------------- SubversionPlugin
SubversionPlugin *SubversionPlugin::m_subversionPluginInstance = 0;

SubversionPlugin::SubversionPlugin() :
180
    VCSBase::VCSBasePlugin(QLatin1String(Subversion::Constants::SUBVERSIONCOMMITEDITOR_KIND)),
181
    m_svnDirectories(svnDirectories()),
con's avatar
con committed
182 183 184 185 186 187 188 189 190
    m_addAction(0),
    m_deleteAction(0),
    m_revertAction(0),
    m_diffProjectAction(0),
    m_diffCurrentAction(0),
    m_commitAllAction(0),
    m_commitCurrentAction(0),
    m_filelogCurrentAction(0),
    m_annotateCurrentAction(0),
191
    m_statusProjectAction(0),
con's avatar
con committed
192
    m_updateProjectAction(0),
193
    m_describeAction(0),
con's avatar
con committed
194 195 196
    m_submitCurrentLogAction(0),
    m_submitDiffAction(0),
    m_submitUndoAction(0),
197
    m_submitRedoAction(0),
198
    m_menuAction(0),
199
    m_submitActionTriggered(false)
con's avatar
con committed
200 201 202 203 204
{
}

SubversionPlugin::~SubversionPlugin()
{
205
    cleanCommitMessageFile();
con's avatar
con committed
206 207
}

208
void SubversionPlugin::cleanCommitMessageFile()
con's avatar
con committed
209
{
210 211 212
    if (!m_commitMessageFileName.isEmpty()) {
        QFile::remove(m_commitMessageFileName);
        m_commitMessageFileName.clear();
213
        m_commitRepository.clear();
con's avatar
con committed
214 215 216
    }
}

217 218 219 220 221
bool SubversionPlugin::isCommitEditorOpen() const
{
    return !m_commitMessageFileName.isEmpty();
}

con's avatar
con committed
222 223 224
static const VCSBase::VCSBaseSubmitEditorParameters submitParameters = {
    Subversion::Constants::SUBVERSION_SUBMIT_MIMETYPE,
    Subversion::Constants::SUBVERSIONCOMMITEDITOR_KIND,
225
    Subversion::Constants::SUBVERSIONCOMMITEDITOR
con's avatar
con committed
226 227
};

228 229 230 231 232 233 234 235 236 237
static inline Core::Command *createSeparator(QObject *parent,
                                             Core::ActionManager *ami,
                                             const char*id,
                                             const QList<int> &globalcontext)
{
    QAction *tmpaction = new QAction(parent);
    tmpaction->setSeparator(true);
    return ami->registerAction(tmpaction, id, globalcontext);
}

238
bool SubversionPlugin::initialize(const QStringList & /*arguments */, QString *errorMessage)
con's avatar
con committed
239 240 241 242 243 244 245 246
{
    typedef VCSBase::VCSSubmitEditorFactory<SubversionSubmitEditor> SubversionSubmitEditorFactory;
    typedef VCSBase::VCSEditorFactory<SubversionEditor> SubversionEditorFactory;
    using namespace Constants;

    using namespace Core::Constants;
    using namespace ExtensionSystem;

247 248
    VCSBase::VCSBasePlugin::initialize(new SubversionControl(this));

con's avatar
con committed
249
    m_subversionPluginInstance = this;
hjk's avatar
hjk committed
250
    Core::ICore *core = Core::ICore::instance();
con's avatar
con committed
251

hjk's avatar
hjk committed
252
    if (!core->mimeDatabase()->addMimeTypes(QLatin1String(":/trolltech.subversion/Subversion.mimetypes.xml"), errorMessage))
con's avatar
con committed
253 254
        return false;

hjk's avatar
hjk committed
255
    if (QSettings *settings = core->settings())
con's avatar
con committed
256 257
        m_settings.fromSettings(settings);

258
    addAutoReleasedObject(new SettingsPage);
con's avatar
con committed
259

260
    addAutoReleasedObject(new SubversionSubmitEditorFactory(&submitParameters));
con's avatar
con committed
261 262 263

    static const char *describeSlot = SLOT(describe(QString,QString));
    const int editorCount = sizeof(editorParameters)/sizeof(VCSBase::VCSBaseEditorParameters);
264 265
    for (int i = 0; i < editorCount; i++)
        addAutoReleasedObject(new SubversionEditorFactory(editorParameters + i, this, describeSlot));
con's avatar
con committed
266

267 268
    addAutoReleasedObject(new CheckoutWizard);

con's avatar
con committed
269
    //register actions
hjk's avatar
hjk committed
270
    Core::ActionManager *ami = core->actionManager();
271
    Core::ActionContainer *toolsContainer = ami->actionContainer(M_TOOLS);
con's avatar
con committed
272

273
    Core::ActionContainer *subversionMenu =
274
        ami->createMenu(QLatin1String(CMD_ID_SUBVERSION_MENU));
con's avatar
con committed
275 276
    subversionMenu->menu()->setTitle(tr("&Subversion"));
    toolsContainer->addMenu(subversionMenu);
277
    m_menuAction = subversionMenu->menu()->menuAction();
con's avatar
con committed
278
    QList<int> globalcontext;
hjk's avatar
hjk committed
279
    globalcontext << core->uniqueIDManager()->uniqueIdentifier(C_GLOBAL);
con's avatar
con committed
280

con's avatar
con committed
281
    Core::Command *command;
282
    m_addAction = new Utils::ParameterAction(tr("Add"), tr("Add \"%1\""), Utils::ParameterAction::EnabledWithParameter, this);
283
    command = ami->registerAction(m_addAction, CMD_ID_ADD,
con's avatar
con committed
284
        globalcontext);
con's avatar
con committed
285
    command->setAttribute(Core::Command::CA_UpdateText);
con's avatar
con committed
286 287 288 289
    command->setDefaultKeySequence(QKeySequence(tr("Alt+S,Alt+A")));
    connect(m_addAction, SIGNAL(triggered()), this, SLOT(addCurrentFile()));
    subversionMenu->addAction(command);

290
    m_deleteAction = new Utils::ParameterAction(tr("Delete"), tr("Delete \"%1\""), Utils::ParameterAction::EnabledWithParameter, this);
291
    command = ami->registerAction(m_deleteAction, CMD_ID_DELETE_FILE,
con's avatar
con committed
292
        globalcontext);
con's avatar
con committed
293
    command->setAttribute(Core::Command::CA_UpdateText);
con's avatar
con committed
294 295 296
    connect(m_deleteAction, SIGNAL(triggered()), this, SLOT(deleteCurrentFile()));
    subversionMenu->addAction(command);

297
    m_revertAction = new Utils::ParameterAction(tr("Revert"), tr("Revert \"%1\""), Utils::ParameterAction::EnabledWithParameter, this);
298
    command = ami->registerAction(m_revertAction, CMD_ID_REVERT,
con's avatar
con committed
299
        globalcontext);
con's avatar
con committed
300
    command->setAttribute(Core::Command::CA_UpdateText);
con's avatar
con committed
301 302 303
    connect(m_revertAction, SIGNAL(triggered()), this, SLOT(revertCurrentFile()));
    subversionMenu->addAction(command);

304
    subversionMenu->addAction(createSeparator(this, ami, CMD_ID_SEPARATOR0, globalcontext));
con's avatar
con committed
305

306
    m_diffProjectAction = new Utils::ParameterAction(tr("Diff Project"), tr("Diff Project \"%1\""), Utils::ParameterAction::EnabledWithParameter, this);
307
    command = ami->registerAction(m_diffProjectAction, CMD_ID_DIFF_PROJECT,
con's avatar
con committed
308
        globalcontext);
309
    command->setAttribute(Core::Command::CA_UpdateText);
con's avatar
con committed
310 311 312
    connect(m_diffProjectAction, SIGNAL(triggered()), this, SLOT(diffProject()));
    subversionMenu->addAction(command);

313
    m_diffCurrentAction = new Utils::ParameterAction(tr("Diff Current File"), tr("Diff \"%1\""), Utils::ParameterAction::EnabledWithParameter, this);
con's avatar
con committed
314
    command = ami->registerAction(m_diffCurrentAction,
315
        CMD_ID_DIFF_CURRENT, globalcontext);
con's avatar
con committed
316
    command->setAttribute(Core::Command::CA_UpdateText);
con's avatar
con committed
317 318 319 320
    command->setDefaultKeySequence(QKeySequence(tr("Alt+S,Alt+D")));
    connect(m_diffCurrentAction, SIGNAL(triggered()), this, SLOT(diffCurrentFile()));
    subversionMenu->addAction(command);

321
    subversionMenu->addAction(createSeparator(this, ami, CMD_ID_SEPARATOR1, globalcontext));
con's avatar
con committed
322 323

    m_commitAllAction = new QAction(tr("Commit All Files"), this);
324
    command = ami->registerAction(m_commitAllAction, CMD_ID_COMMIT_ALL,
con's avatar
con committed
325 326 327 328
        globalcontext);
    connect(m_commitAllAction, SIGNAL(triggered()), this, SLOT(startCommitAll()));
    subversionMenu->addAction(command);

329
    m_commitCurrentAction = new Utils::ParameterAction(tr("Commit Current File"), tr("Commit \"%1\""), Utils::ParameterAction::EnabledWithParameter, this);
con's avatar
con committed
330
    command = ami->registerAction(m_commitCurrentAction,
331
        CMD_ID_COMMIT_CURRENT, globalcontext);
con's avatar
con committed
332
    command->setAttribute(Core::Command::CA_UpdateText);
con's avatar
con committed
333 334 335 336
    command->setDefaultKeySequence(QKeySequence(tr("Alt+S,Alt+C")));
    connect(m_commitCurrentAction, SIGNAL(triggered()), this, SLOT(startCommitCurrentFile()));
    subversionMenu->addAction(command);

337
    subversionMenu->addAction(createSeparator(this, ami, CMD_ID_SEPARATOR2, globalcontext));
con's avatar
con committed
338

339
    m_filelogCurrentAction = new Utils::ParameterAction(tr("Filelog Current File"), tr("Filelog \"%1\""), Utils::ParameterAction::EnabledWithParameter, this);
con's avatar
con committed
340
    command = ami->registerAction(m_filelogCurrentAction,
341
        CMD_ID_FILELOG_CURRENT, globalcontext);
con's avatar
con committed
342
    command->setAttribute(Core::Command::CA_UpdateText);
con's avatar
con committed
343 344 345 346
    connect(m_filelogCurrentAction, SIGNAL(triggered()), this,
        SLOT(filelogCurrentFile()));
    subversionMenu->addAction(command);

347
    m_annotateCurrentAction = new Utils::ParameterAction(tr("Annotate Current File"), tr("Annotate \"%1\""), Utils::ParameterAction::EnabledWithParameter, this);
con's avatar
con committed
348
    command = ami->registerAction(m_annotateCurrentAction,
349
        CMD_ID_ANNOTATE_CURRENT, globalcontext);
con's avatar
con committed
350
    command->setAttribute(Core::Command::CA_UpdateText);
con's avatar
con committed
351 352 353 354
    connect(m_annotateCurrentAction, SIGNAL(triggered()), this,
        SLOT(annotateCurrentFile()));
    subversionMenu->addAction(command);

355
    m_describeAction = new QAction(tr("Describe..."), this);
356
    command = ami->registerAction(m_describeAction, CMD_ID_DESCRIBE, globalcontext);
357 358 359
    connect(m_describeAction, SIGNAL(triggered()), this, SLOT(slotDescribe()));
    subversionMenu->addAction(command);

360
    subversionMenu->addAction(createSeparator(this, ami, CMD_ID_SEPARATOR3, globalcontext));
con's avatar
con committed
361

362 363
    m_statusProjectAction = new Utils::ParameterAction(tr("Project Status"), tr("Status of Project \"%1\""), Utils::ParameterAction::EnabledWithParameter, this);
    command = ami->registerAction(m_statusProjectAction, CMD_ID_STATUS,
con's avatar
con committed
364
        globalcontext);
365 366
    command->setAttribute(Core::Command::CA_UpdateText);
    connect(m_statusProjectAction, SIGNAL(triggered()), this, SLOT(projectStatus()));
con's avatar
con committed
367 368
    subversionMenu->addAction(command);

369
    m_updateProjectAction = new Utils::ParameterAction(tr("Update Project"), tr("Update Project \"%1\""), Utils::ParameterAction::EnabledWithParameter, this);
370
    command = ami->registerAction(m_updateProjectAction, CMD_ID_UPDATE, globalcontext);
con's avatar
con committed
371
    connect(m_updateProjectAction, SIGNAL(triggered()), this, SLOT(updateProject()));
372
    command->setAttribute(Core::Command::CA_UpdateText);
con's avatar
con committed
373 374 375 376
    subversionMenu->addAction(command);

    // Actions of the submit editor
    QList<int> svncommitcontext;
377
    svncommitcontext << Core::UniqueIDManager::instance()->uniqueIdentifier(Constants::SUBVERSIONCOMMITEDITOR);
con's avatar
con committed
378

379
    m_submitCurrentLogAction = new QAction(VCSBase::VCSBaseSubmitEditor::submitIcon(), tr("Commit"), this);
con's avatar
con committed
380 381 382
    command = ami->registerAction(m_submitCurrentLogAction, Constants::SUBMIT_CURRENT, svncommitcontext);
    connect(m_submitCurrentLogAction, SIGNAL(triggered()), this, SLOT(submitCurrentLog()));

383
    m_submitDiffAction = new QAction(VCSBase::VCSBaseSubmitEditor::diffIcon(), tr("Diff Selected Files"), this);
con's avatar
con committed
384 385 386 387 388 389 390 391 392 393 394 395 396 397 398
    command = ami->registerAction(m_submitDiffAction , Constants::DIFF_SELECTED, svncommitcontext);

    m_submitUndoAction = new QAction(tr("&Undo"), this);
    command = ami->registerAction(m_submitUndoAction, Core::Constants::UNDO, svncommitcontext);

    m_submitRedoAction = new QAction(tr("&Redo"), this);
    command = ami->registerAction(m_submitRedoAction, Core::Constants::REDO, svncommitcontext);

    return true;
}

void SubversionPlugin::extensionsInitialized()
{
}

399
bool SubversionPlugin::submitEditorAboutToClose(VCSBase::VCSBaseSubmitEditor *submitEditor)
con's avatar
con committed
400
{
401
    if (!isCommitEditorOpen())
con's avatar
con committed
402 403
        return true;

404 405
    Core::IFile *fileIFace = submitEditor->file();
    const SubversionSubmitEditor *editor = qobject_cast<SubversionSubmitEditor *>(submitEditor);
con's avatar
con committed
406 407 408 409 410 411
    if (!fileIFace || !editor)
        return true;

    // Submit editor closing. Make it write out the commit message
    // and retrieve files
    const QFileInfo editorFile(fileIFace->fileName());
412
    const QFileInfo changeFile(m_commitMessageFileName);
con's avatar
con committed
413 414 415
    if (editorFile.absoluteFilePath() != changeFile.absoluteFilePath())
        return true; // Oops?!

416 417
    // Prompt user. Force a prompt unless submit was actually invoked (that
    // is, the editor was closed or shutdown).
418
    SubversionSettings newSettings = m_settings;
419 420 421
    const VCSBase::VCSBaseSubmitEditor::PromptSubmitResult answer =
            editor->promptSubmit(tr("Closing Subversion Editor"),
                                 tr("Do you want to commit the change?"),
422
                                 tr("The commit message check failed. Do you want to commit the change?"),
423
                                 &newSettings.promptToSubmit, !m_submitActionTriggered);
424
    m_submitActionTriggered = false;
con's avatar
con committed
425
    switch (answer) {
426
    case VCSBase::VCSBaseSubmitEditor::SubmitCanceled:
con's avatar
con committed
427
        return false; // Keep editing and change file
428
    case VCSBase::VCSBaseSubmitEditor::SubmitDiscarded:
429
        cleanCommitMessageFile();
con's avatar
con committed
430 431 432 433
        return true; // Cancel all
    default:
        break;
    }
434
    setSettings(newSettings); // in case someone turned prompting off
con's avatar
con committed
435
    const QStringList fileList = editor->checkedFiles();
436
    bool closeEditor = true;
con's avatar
con committed
437 438
    if (!fileList.empty()) {
        // get message & commit
hjk's avatar
hjk committed
439
        Core::ICore::instance()->fileManager()->blockFileChange(fileIFace);
con's avatar
con committed
440
        fileIFace->save();
hjk's avatar
hjk committed
441
        Core::ICore::instance()->fileManager()->unblockFileChange(fileIFace);
442
        closeEditor= commit(m_commitMessageFileName, fileList);
con's avatar
con committed
443
    }
444
    if (closeEditor)
445
        cleanCommitMessageFile();
446
    return closeEditor;
con's avatar
con committed
447 448
}

449
void SubversionPlugin::diffCommitFiles(const QStringList &files)
con's avatar
con committed
450
{
451
    svnDiff(m_commitRepository, files);
con's avatar
con committed
452 453
}

454
void SubversionPlugin::svnDiff(const QString &workingDir, const QStringList &files, QString diffname)
con's avatar
con committed
455 456 457
{
    if (Subversion::Constants::debug)
        qDebug() << Q_FUNC_INFO << files << diffname;
458
    const QString source = VCSBase::VCSBaseEditor::getSource(workingDir, files);
459
    QTextCodec *codec = source.isEmpty() ? static_cast<QTextCodec *>(0) : VCSBase::VCSBaseEditor::getCodec(source);
con's avatar
con committed
460 461 462 463 464 465 466

    if (files.count() == 1 && diffname.isEmpty())
        diffname = QFileInfo(files.front()).fileName();

    QStringList args(QLatin1String("diff"));
    args << files;

467
    const SubversionResponse response = runSvn(workingDir, args, subversionShortTimeOut, false, codec);
con's avatar
con committed
468 469 470 471 472 473 474
    if (response.error)
        return;

    // diff of a single file? re-use an existing view if possible to support
    // the common usage pattern of continuously changing and diffing a file
    if (files.count() == 1) {
        // Show in the same editor if diff has been executed before
hjk's avatar
hjk committed
475
        if (Core::IEditor *editor = locateEditor("originalFileName", files.front())) {
con's avatar
con committed
476
            editor->createNew(response.stdOut);
477
            Core::EditorManager::instance()->activateEditor(editor);
con's avatar
con committed
478 479 480
            return;
        }
    }
Oswald Buddenhagen's avatar
Oswald Buddenhagen committed
481
    const QString title = QString::fromLatin1("svn diff %1").arg(diffname);
con's avatar
con committed
482 483 484 485 486 487 488
    Core::IEditor *editor = showOutputInEditor(title, response.stdOut, VCSBase::DiffOutput, source, codec);
    if (files.count() == 1)
        editor->setProperty("originalFileName", files.front());
}

SubversionSubmitEditor *SubversionPlugin::openSubversionSubmitEditor(const QString &fileName)
{
489
    Core::IEditor *editor = Core::EditorManager::instance()->openEditor(fileName, QLatin1String(Constants::SUBVERSIONCOMMITEDITOR_KIND));
con's avatar
con committed
490
    SubversionSubmitEditor *submitEditor = qobject_cast<SubversionSubmitEditor*>(editor);
hjk's avatar
hjk committed
491
    QTC_ASSERT(submitEditor, /**/);
492
    submitEditor->registerActions(m_submitUndoAction, m_submitRedoAction, m_submitCurrentLogAction, m_submitDiffAction);
493
    connect(submitEditor, SIGNAL(diffSelectedFiles(QStringList)), this, SLOT(diffCommitFiles(QStringList)));
con's avatar
con committed
494 495 496 497

    return submitEditor;
}

498
void SubversionPlugin::updateActions(VCSBase::VCSBasePlugin::ActionState as)
con's avatar
con committed
499
{
500 501 502
    if (!VCSBase::VCSBasePlugin::enableMenuAction(as, m_menuAction))
        return;

503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520
    const QString projectName = currentState().currentProjectName();
    m_diffProjectAction->setParameter(projectName);
    m_statusProjectAction->setParameter(projectName);
    m_updateProjectAction->setParameter(projectName);

    const bool repoEnabled = currentState().hasTopLevel();
    m_commitAllAction->setEnabled(repoEnabled);
    m_describeAction->setEnabled(repoEnabled);

    const QString fileName = currentState().currentFileName();

    m_addAction->setParameter(fileName);
    m_deleteAction->setParameter(fileName);
    m_revertAction->setParameter(fileName);
    m_diffCurrentAction->setParameter(fileName);
    m_commitCurrentAction->setParameter(fileName);
    m_filelogCurrentAction->setParameter(fileName);
    m_annotateCurrentAction->setParameter(fileName);
con's avatar
con committed
521 522 523 524
}

void SubversionPlugin::addCurrentFile()
{
525 526 527
    const VCSBase::VCSBasePluginState state = currentState();
    QTC_ASSERT(state.hasFile(), return)
    vcsAdd(state.currentFileTopLevel(), state.relativeCurrentFile());
con's avatar
con committed
528 529 530 531
}

void SubversionPlugin::deleteCurrentFile()
{
532 533 534
    const VCSBase::VCSBasePluginState state = currentState();
    QTC_ASSERT(state.hasFile(), return)
    vcsDelete(state.currentFileTopLevel(), state.relativeCurrentFile());
con's avatar
con committed
535 536 537 538
}

void SubversionPlugin::revertCurrentFile()
{
539 540
    const VCSBase::VCSBasePluginState state = currentState();
    QTC_ASSERT(state.hasFile(), return)
con's avatar
con committed
541 542

    QStringList args(QLatin1String("diff"));
543
    args.push_back(state.relativeCurrentFile());
con's avatar
con committed
544

545
    const SubversionResponse diffResponse = runSvn(state.currentFileTopLevel(), args, subversionShortTimeOut, false);
con's avatar
con committed
546 547 548 549 550
    if (diffResponse.error)
        return;

    if (diffResponse.stdOut.isEmpty())
        return;
Oswald Buddenhagen's avatar
Oswald Buddenhagen committed
551
    if (QMessageBox::warning(0, QLatin1String("svn revert"), tr("The file has been changed. Do you want to revert it?"),
con's avatar
con committed
552 553 554
                             QMessageBox::Yes, QMessageBox::No) == QMessageBox::No)
        return;

555

556
    Core::FileChangeBlocker fcb(state.currentFile());
con's avatar
con committed
557 558 559

    // revert
    args.clear();
560
    args << QLatin1String("revert") << state.relativeCurrentFile();
con's avatar
con committed
561

562
    const SubversionResponse revertResponse = runSvn(state.currentFileTopLevel(), args, subversionShortTimeOut, true);
563 564
    if (!revertResponse.error) {
        fcb.setModifiedReload(true);
565
        subVersionControl()->emitFilesChanged(QStringList(state.currentFile()));
con's avatar
con committed
566 567 568 569 570
    }
}

void SubversionPlugin::diffProject()
{
571 572 573
    const VCSBase::VCSBasePluginState state = currentState();
    QTC_ASSERT(state.hasProject(), return)
    svnDiff(state.currentProjectTopLevel(), state.relativeCurrentProject(), state.currentProjectName());
con's avatar
con committed
574 575 576 577
}

void SubversionPlugin::diffCurrentFile()
{
578 579 580
    const VCSBase::VCSBasePluginState state = currentState();
    QTC_ASSERT(state.hasFile(), return)
    svnDiff(state.currentFileTopLevel(), QStringList(state.relativeCurrentFile()));
con's avatar
con committed
581 582 583 584
}

void SubversionPlugin::startCommitCurrentFile()
{
585 586 587
    const VCSBase::VCSBasePluginState state = currentState();
    QTC_ASSERT(state.hasFile(), return)
    startCommit(state.currentFileTopLevel(), QStringList(state.relativeCurrentFile()));
con's avatar
con committed
588 589 590 591
}

void SubversionPlugin::startCommitAll()
{
592 593 594
    const VCSBase::VCSBasePluginState state = currentState();
    QTC_ASSERT(state.hasTopLevel(), return);
    startCommit(state.topLevel());
con's avatar
con committed
595 596 597 598 599
}

/* Start commit of files of a single repository by displaying
 * template and files in a submit editor. On closing, the real
 * commit will start. */
600
void SubversionPlugin::startCommit(const QString &workingDir, const QStringList &files)
con's avatar
con committed
601
{
602 603
    if (VCSBase::VCSBaseSubmitEditor::raiseSubmitEditor())
        return;
604
    if (isCommitEditorOpen()) {
605
        VCSBase::VCSBaseOutputWindow::instance()->appendWarning(tr("Another commit is currently being executed."));
con's avatar
con committed
606 607 608 609 610 611
        return;
    }

    QStringList args(QLatin1String("status"));
    args += files;

612
    const SubversionResponse response = runSvn(workingDir, args, subversionShortTimeOut, false);
con's avatar
con committed
613 614
    if (response.error)
        return;
615

con's avatar
con committed
616
    // Get list of added/modified/deleted files
617
    const StatusList statusOutput = parseStatusOutput(response.stdOut);
con's avatar
con committed
618
    if (statusOutput.empty()) {
619
        VCSBase::VCSBaseOutputWindow::instance()->appendWarning(tr("There are no modified files."));
con's avatar
con committed
620 621
        return;
    }
622
    m_commitRepository = workingDir;
con's avatar
con committed
623
    // Create a new submit change file containing the submit template
624 625 626 627
    QTemporaryFile changeTmpFile;
    changeTmpFile.setAutoRemove(false);
    if (!changeTmpFile.open()) {
        VCSBase::VCSBaseOutputWindow::instance()->appendError(tr("Cannot create temporary file: %1").arg(changeTmpFile.errorString()));
con's avatar
con committed
628 629
        return;
    }
630
    m_commitMessageFileName = changeTmpFile.fileName();
631
    // TODO: Regitctrieve submit template from
con's avatar
con committed
632 633
    const QString submitTemplate;
    // Create a submit
634 635 636
    changeTmpFile.write(submitTemplate.toUtf8());
    changeTmpFile.flush();
    changeTmpFile.close();
con's avatar
con committed
637
    // Create a submit editor and set file list
638
    SubversionSubmitEditor *editor = openSubversionSubmitEditor(m_commitMessageFileName);
639
    editor->setStatusList(statusOutput);
con's avatar
con committed
640 641 642 643 644 645 646 647 648 649 650
}

bool SubversionPlugin::commit(const QString &messageFile,
                              const QStringList &subVersionFileList)
{
    if (Subversion::Constants::debug)
        qDebug() << Q_FUNC_INFO << messageFile << subVersionFileList;
    // Transform the status list which is sth
    // "[ADM]<blanks>file" into an args list. The files of the status log
    // can be relative or absolute depending on where the command was run.
    QStringList args = QStringList(QLatin1String("commit"));
651
    args << QLatin1String(nonInteractiveOptionC) << QLatin1String("--file") << messageFile;
con's avatar
con committed
652
    args.append(subVersionFileList);
653
    const SubversionResponse response = runSvn(m_commitRepository, args, subversionLongTimeOut, true);
con's avatar
con committed
654 655 656 657 658
    return !response.error ;
}

void SubversionPlugin::filelogCurrentFile()
{
659 660 661
    const VCSBase::VCSBasePluginState state = currentState();
    QTC_ASSERT(state.hasFile(), return)
   filelog(state.currentFileTopLevel(), QStringList(state.relativeCurrentFile()));
con's avatar
con committed
662 663
}

664
void SubversionPlugin::filelog(const QString &workingDir, const QStringList &files)
con's avatar
con committed
665
{
666
    QTextCodec *codec = VCSBase::VCSBaseEditor::getCodec(workingDir, files);
con's avatar
con committed
667 668
    // no need for temp file
    QStringList args(QLatin1String("log"));
669 670
    foreach(const QString &file, files)
        args.append(QDir::toNativeSeparators(file));
con's avatar
con committed
671

672
    const SubversionResponse response = runSvn(workingDir, args, subversionShortTimeOut, false, codec);
con's avatar
con committed
673 674 675 676 677 678
    if (response.error)
        return;

    // Re-use an existing view if possible to support
    // the common usage pattern of continuously changing and diffing a file

679 680
    const QString id = VCSBase::VCSBaseEditor::getTitleId(workingDir, files);
    if (Core::IEditor *editor = locateEditor("logFileName", id)) {
con's avatar
con committed
681
        editor->createNew(response.stdOut);
682
        Core::EditorManager::instance()->activateEditor(editor);
con's avatar
con committed
683
    } else {
684 685 686 687
        const QString title = QString::fromLatin1("svn log %1").arg(id);
        const QString source = VCSBase::VCSBaseEditor::getSource(workingDir, files);
        Core::IEditor *newEditor = showOutputInEditor(title, response.stdOut, VCSBase::LogOutput, source, codec);
        newEditor->setProperty("logFileName", id);
con's avatar
con committed
688 689 690 691 692
    }
}

void SubversionPlugin::updateProject()
{
693 694
    const VCSBase::VCSBasePluginState state = currentState();
    QTC_ASSERT(state.hasProject(), return);
con's avatar
con committed
695 696

    QStringList args(QLatin1String("update"));
697
    args.push_back(QLatin1String(nonInteractiveOptionC));
698 699 700 701
    args.append(state.relativeCurrentProject());
    const SubversionResponse response = runSvn(state.currentProjectTopLevel(), args, subversionLongTimeOut, true);
    if (!response.error)
        subVersionControl()->emitRepositoryChanged(state.currentProjectTopLevel());
con's avatar
con committed
702 703 704 705
}

void SubversionPlugin::annotateCurrentFile()
{
706 707 708
    const VCSBase::VCSBasePluginState state = currentState();
    QTC_ASSERT(state.hasFile(), return);
    annotate(state.currentFileTopLevel(), state.relativeCurrentFile());
con's avatar
con committed
709 710
}

711
void SubversionPlugin::annotate(const QString &workingDir, const QString &file)
con's avatar
con committed
712
{
713
    QTextCodec *codec = VCSBase::VCSBaseEditor::getCodec(file);
con's avatar
con committed
714 715 716 717 718

    QStringList args(QLatin1String("annotate"));
    args.push_back(QLatin1String("-v"));
    args.append(QDir::toNativeSeparators(file));

719
    const SubversionResponse response = runSvn(workingDir, args, subversionShortTimeOut, false, codec);
con's avatar
con committed
720 721 722 723 724
    if (response.error)
        return;

    // Re-use an existing view if possible to support
    // the common usage pattern of continuously changing and diffing a file
725 726 727
    const QString source = workingDir + QLatin1Char('/') + file;
    const int lineNumber = VCSBase::VCSBaseEditor::lineNumberOfCurrentEditor(source);
    const QString id = VCSBase::VCSBaseEditor::getTitleId(workingDir, QStringList(file));
con's avatar
con committed
728

729
    if (Core::IEditor *editor = locateEditor("annotateFileName", id)) {
con's avatar
con committed
730
        editor->createNew(response.stdOut);
731 732
        VCSBase::VCSBaseEditor::gotoLineOfEditor(editor, lineNumber);
        Core::EditorManager::instance()->activateEditor(editor);        
con's avatar
con committed
733
    } else {
734 735 736
        const QString title = QString::fromLatin1("svn annotate %1").arg(id);
        Core::IEditor *newEditor = showOutputInEditor(title, response.stdOut, VCSBase::AnnotateOutput, source, codec);
        newEditor->setProperty("annotateFileName", id);
737
        VCSBase::VCSBaseEditor::gotoLineOfEditor(newEditor, lineNumber);
con's avatar
con committed
738 739 740 741 742
    }
}

void SubversionPlugin::projectStatus()
{
743 744
    const VCSBase::VCSBasePluginState state = currentState();
    QTC_ASSERT(state.hasProject(), return);
con's avatar
con committed
745
    QStringList args(QLatin1String("status"));
746 747
    args += state.relativeCurrentProject();
    runSvn(state.currentProjectTopLevel(), args, subversionShortTimeOut, true);
con's avatar
con committed
748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764
}

void SubversionPlugin::describe(const QString &source, const QString &changeNr)
{
    // To describe a complete change, find the top level and then do
    //svn diff -r 472958:472959 <top level>
    const QFileInfo fi(source);
    const QString topLevel = findTopLevelForDirectory(fi.isDir() ? source : fi.absolutePath());
    if (topLevel.isEmpty())
        return;
    if (Subversion::Constants::debug)
        qDebug() << Q_FUNC_INFO << source << topLevel << changeNr;
    // Number must be > 1
    bool ok;
    const int number = changeNr.toInt(&ok);
    if (!ok || number < 2)
        return;
765 766 767 768 769
    // Run log to obtain message (local utf8)
    QString description;
    QStringList args(QLatin1String("log"));
    args.push_back(QLatin1String("-r"));
    args.push_back(changeNr);
770
    const SubversionResponse logResponse = runSvn(topLevel, args, subversionShortTimeOut, false);
771 772 773 774 775 776 777
    if (logResponse.error)
        return;
    description = logResponse.stdOut;

    // Run diff (encoding via source codec)
    args.clear();
    args.push_back(QLatin1String("diff"));
con's avatar
con committed
778 779 780 781 782
    args.push_back(QLatin1String("-r"));
    QString diffArg;
    QTextStream(&diffArg) << (number - 1) << ':' << number;
    args.push_back(diffArg);

783
    QTextCodec *codec = VCSBase::VCSBaseEditor::getCodec(source);
784
    const SubversionResponse response = runSvn(topLevel, args, subversionShortTimeOut, false, codec);
con's avatar
con committed
785 786
    if (response.error)
        return;
787
    description += response.stdOut;
con's avatar
con committed
788 789 790 791

    // Re-use an existing view if possible to support
    // the common usage pattern of continuously changing and diffing a file
    const QString id = diffArg + source;
hjk's avatar
hjk committed
792
    if (Core::IEditor *editor = locateEditor("describeChange", id)) {
793
        editor->createNew(description);
hjk's avatar
hjk committed
794
        Core::EditorManager::instance()->activateEditor(editor);
con's avatar
con committed
795
    } else {
796
        const QString title = QString::fromLatin1("svn describe %1#%2").arg(fi.fileName(), changeNr);
797
        Core::IEditor *newEditor = showOutputInEditor(title, description, VCSBase::DiffOutput, source, codec);
con's avatar
con committed
798 799 800 801
        newEditor->setProperty("describeChange", id);
    }
}

802 803
void SubversionPlugin::slotDescribe()
{
804 805
    const VCSBase::VCSBasePluginState state = currentState();
    QTC_ASSERT(state.hasTopLevel(), return);
806 807 808 809 810 811 812 813 814 815 816

    QInputDialog inputDialog(Core::ICore::instance()->mainWindow());
    inputDialog.setWindowFlags(inputDialog.windowFlags() & ~Qt::WindowContextHelpButtonHint);
    inputDialog.setInputMode(QInputDialog::IntInput);
    inputDialog.setIntRange(2, INT_MAX);
    inputDialog.setWindowTitle(tr("Describe"));
    inputDialog.setLabelText(tr("Revision number:"));
    if (inputDialog.exec() != QDialog::Accepted)
        return;

    const int revision = inputDialog.intValue();
817
    describe(state.topLevel(), QString::number(revision));
818 819
}

con's avatar
con committed
820 821
void SubversionPlugin::submitCurrentLog()
{
822
    m_submitActionTriggered = true;
823 824
    Core::EditorManager::instance()->closeEditors(QList<Core::IEditor*>()
        << Core::EditorManager::instance()->currentEditor());
con's avatar
con committed
825 826 827 828 829 830 831 832 833 834 835 836 837 838
}

static inline QString processStdErr(QProcess &proc)
{
    return QString::fromLocal8Bit(proc.readAllStandardError()).remove(QLatin1Char('\r'));
}

static inline QString processStdOut(QProcess &proc, QTextCodec *outputCodec = 0)
{
    const QByteArray stdOutData = proc.readAllStandardOutput();
    QString stdOut = outputCodec ? outputCodec->toUnicode(stdOutData) : QString::fromLocal8Bit(stdOutData);
    return stdOut.remove(QLatin1Char('\r'));
}

839 840
SubversionResponse SubversionPlugin::runSvn(const QString &workingDir,
                                            const QStringList &arguments,
con's avatar
con committed
841 842 843 844 845 846 847 848 849 850 851 852 853
                                            int timeOut,
                                            bool showStdOutInOutputWindow,
                                            QTextCodec *outputCodec)
{
    const QString executable = m_settings.svnCommand;
    SubversionResponse response;
    if (executable.isEmpty()) {
        response.error = true;
        response.message =tr("No subversion executable specified!");
        return response;
    }
    const QStringList allArgs = m_settings.addOptions(arguments);

854
    VCSBase::VCSBaseOutputWindow *outputWindow = VCSBase::VCSBaseOutputWindow::instance();
con's avatar
con committed
855
    // Hide passwords, etc in the log window
856 857 858
    //: Executing: <executable> <arguments>
    const QString outputText = tr("Executing: %1 %2\n").arg(executable, SubversionSettings::formatArguments(allArgs));
    outputWindow->appendCommand(outputText);
con's avatar
con committed
859 860 861 862 863

    if (Subversion::Constants::debug)
        qDebug() << "runSvn" << timeOut << outputText;

    // Run, connect stderr to the output window
864
    Utils::SynchronousProcess process;
865 866
    if (!workingDir.isEmpty())
        process.setWorkingDirectory(workingDir);
con's avatar
con committed
867 868 869 870
    process.setTimeout(timeOut);
    process.setStdOutCodec(outputCodec);

    process.setStdErrBufferedSignalsEnabled(true);
871
    connect(&process, SIGNAL(stdErrBuffered(QString,bool)), outputWindow, SLOT(append(QString)));
con's avatar
con committed
872 873 874 875

    // connect stdout to the output window if desired
    if (showStdOutInOutputWindow) {
        process.setStdOutBufferedSignalsEnabled(true);
876
        connect(&process, SIGNAL(stdOutBuffered(QString,bool)), outputWindow, SLOT(append(QString)));
con's avatar
con committed
877 878
    }

879
    const Utils::SynchronousProcessResponse sp_resp = process.run(executable, allArgs);
con's avatar
con committed
880 881 882 883
    response.error = true;
    response.stdErr = sp_resp.stdErr;
    response.stdOut = sp_resp.stdOut;
    switch (sp_resp.result) {
884
    case Utils::SynchronousProcessResponse::Finished:
con's avatar
con committed
885 886
        response.error = false;
        break;
887
    case Utils::SynchronousProcessResponse::FinishedError:
con's avatar
con committed
888 889
        response.message = tr("The process terminated with exit code %1.").arg(sp_resp.exitCode);
        break;
890
    case Utils::SynchronousProcessResponse::TerminatedAbnormally:
con's avatar
con committed
891 892
        response.message = tr("The process terminated abnormally.");
        break;
893
    case Utils::SynchronousProcessResponse::StartFailed:
con's avatar
con committed
894 895
        response.message = tr("Could not start subversion '%1'. Please check your settings in the preferences.").arg(executable);
        break;
896
    case Utils::SynchronousProcessResponse::Hang:
con's avatar
con committed
897 898 899 900
        response.message = tr("Subversion did not respond within timeout limit (%1 ms).").arg(timeOut);
        break;
    }
    if (response.error)
901
        outputWindow->appendError(response.message);
con's avatar
con committed
902 903 904 905 906 907 908 909 910

    return response;
}

Core::IEditor * SubversionPlugin::showOutputInEditor(const QString& title, const QString &output,
                                                     int editorType, const QString &source,
                                                     QTextCodec *codec)
{
    const VCSBase::VCSBaseEditorParameters *params = findType(editorType);
hjk's avatar
hjk committed
911
    QTC_ASSERT(params, return 0);
con's avatar
con committed
912 913 914 915
    const QString kind = QLatin1String(params->kind);
    if (Subversion::Constants::debug)
        qDebug() << "SubversionPlugin::showOutputInEditor" << title << kind <<  "Size= " << output.size() <<  " Type=" << editorType << debugCodec(codec);
    QString s = title;
con's avatar
con committed
916
    Core::IEditor *editor = Core::EditorManager::instance()->openEditorWithContents(kind, &s, output);
917
    SubversionEditor *e = qobject_cast<SubversionEditor*>(editor->widget());
con's avatar
con committed
918 919 920 921 922 923 924 925
    if (!e)
        return 0;
    s.replace(QLatin1Char(' '), QLatin1Char('_'));
    e->setSuggestedFileName(s);
    if (!source.isEmpty())
        e->setSource(source);
    if (codec)
        e->setCodec(codec);
926 927 928
    Core::IEditor *ie = e->editableInterface();
    Core::EditorManager::instance()->activateEditor(ie);
    return ie;
con's avatar
con committed
929 930 931 932 933 934 935 936 937 938 939
}

SubversionSettings SubversionPlugin::settings() const
{
    return m_settings;
}

void SubversionPlugin::setSettings(const SubversionSettings &s)
{
    if (s != m_settings) {
        m_settings = s;
hjk's avatar
hjk committed
940
        if (QSettings *settings = Core::ICore::instance()->settings())
con's avatar
con committed
941 942 943 944 945 946
            m_settings.toSettings(settings);
    }
}

SubversionPlugin *SubversionPlugin::subversionPluginInstance()
{
hjk's avatar
hjk committed
947
    QTC_ASSERT(m_subversionPluginInstance, return m_subversionPluginInstance);
con's avatar
con committed
948 949 950
    return m_subversionPluginInstance;
}

951
bool SubversionPlugin::vcsAdd(const QString &workingDir, const QString &rawFileName)
con's avatar
con committed
952 953 954 955 956
{
    const QString file = QDir::toNativeSeparators(rawFileName);
    QStringList args(QLatin1String("add"));
    args.push_back(file);

957
    const SubversionResponse response = runSvn(workingDir, args, subversionShortTimeOut, true);
con's avatar
con committed
958 959 960
    return !response.error;
}

961
bool SubversionPlugin::vcsDelete(const QString &workingDir, const QString &rawFileName)
con's avatar
con committed
962 963 964 965 966 967
{
    const QString file = QDir::toNativeSeparators(rawFileName);

    QStringList args(QLatin1String("delete"));
    args.push_back(file);

968
    const SubversionResponse response = runSvn(workingDir, args, subversionShortTimeOut, true);
con's avatar
con committed
969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985
    return !response.error;
}

/* Subversion has ".svn" directory in each directory
 * it manages. The top level is the first directory
 * under the directory that does not have a  ".svn". */
bool SubversionPlugin::managesDirectory(const QString &directory) const
{
    const QDir dir(directory);
    const bool rc = dir.exists() && managesDirectory(dir);
    if (Subversion::Constants::debug)
        qDebug() << "SubversionPlugin::managesDirectory" << directory << rc;
    return rc;
}

bool SubversionPlugin::managesDirectory(const QDir &directory) const
{
986 987 988 989 990 991 992
    const int dirCount = m_svnDirectories.size();
    for (int i = 0; i < dirCount; i++) {
        const QString svnDir = directory.absoluteFilePath(m_svnDirectories.at(i));
        if (QFileInfo(svnDir).isDir())
            return true;
    }
    return false;
con's avatar
con committed
993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018
}

QString SubversionPlugin::findTopLevelForDirectory(const QString &directory) const
{
    // Debug wrapper
    const QString rc = findTopLevelForDirectoryI(directory);
    if (Subversion::Constants::debug)
        qDebug() << "SubversionPlugin::findTopLevelForDirectory" << directory << rc;
    return rc;
}

QString SubversionPlugin::findTopLevelForDirectoryI(const QString &directory) const
{
    /* Recursing up, the top level is a child of the first directory that does
     * not have a  ".svn" directory. The starting directory must be a managed
     * one. Go up and try to find the first unmanaged parent dir. */
    QDir lastDirectory = QDir(directory);
    if (!lastDirectory.exists() || !managesDirectory(lastDirectory))
        return QString();
    for (QDir parentDir = lastDirectory; parentDir.cdUp() ; lastDirectory = parentDir) {
        if (!managesDirectory(parentDir))
            return QDir::toNativeSeparators(lastDirectory.absolutePath());
    }
    return QString();
}