svn.cpp

Go to the documentation of this file.

/*
 Modular Psi - A graph tracker of the Parapsychologcal scientific development
 Copyright (C) 2005 Leonardo Stern

 This program is free software; you can redistribute it and/or modify it under
 the terms of the Common Public License Version 1.0 or (at your option) any later version.

 This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 See the Common Public License for more details.

 You should have received a copy of the Common Public License along with this program;
*/

#include "svn.hpp"
#include "gui/principal.h"

Svn::Svn(Principal* cl) : 
        needs_refresh_(false), out_win_(cl->messagesBrowser), show_enable_(true), parent_(cl)
{
        caller = cl;
        proc = new QProcess(this);
        svn_ = "svn";
        is_ready_for_last_command_ = false;
        connect(proc, SIGNAL(readyReadStdout()), this, SLOT(readFromStdout()) );
        connect(proc, SIGNAL(readyReadStderr()), this, SLOT(readFromStderr()) );
        connect(proc, SIGNAL(processExited()), this, SLOT(procFinished()) );
};

void Svn::common(QString command)
{
        proc->clearArguments();
        proc->addArgument(svn_);
        proc->addArgument(command);
}

int Svn::diff(const QString& file_dir_name_1, const QString& file_dir_name_2, 
                        const QString& rev, bool use_external_cmd, bool non_recursive, bool notice_ancestry, 
                        const QString& extensions,  QStringList& out_txt) 
{
        common("diff");

        if (rev != "") {
                proc->addArgument("-r");
                proc->addArgument(rev);
        }

        if (!file_dir_name_1.isEmpty()) {
                if (!file_dir_name_2.isEmpty()) {
                        proc->addArgument("--old");
                        proc->addArgument(QDir::convertSeparators(file_dir_name_1));
                        proc->addArgument("--new");
                        proc->addArgument(QDir::convertSeparators(file_dir_name_2));
                } else {
                        // Simple syntax
                        proc->addArgument(QDir::convertSeparators(file_dir_name_1));
                }
        }

        if (non_recursive) 
                proc->addArgument("--non-recursive");

        if (notice_ancestry) 
                proc->addArgument("--notice-ancestry");

        if (!extensions.isEmpty()) {
                proc->addArgument("--extensions");
                proc->addArgument(extensions);      
        }

        if (use_external_cmd) {
                proc->addArgument("--diff-cmd");
                return execCommand(false);
        }
        else    
        return execCommand(SC_APPEND_USER_PASS, &out_txt);
}

int Svn::update(const QString& revision)
{
        common("update");

        if (revision != "") {
                proc->addArgument("-r");
                proc->addArgument(revision);
        }
        proc->addArgument(caller->wd);
        return execCommand(SC_REFRESH | SC_APPEND_USER_PASS | SC_WAIT);
}

int Svn::log(const QString& filename, bool is_verbouse, bool stop_on_copy, QStringList& out_txt)
{
        common("log");
        if (is_verbouse)
                proc->addArgument("--verbose");
        if (stop_on_copy)
                proc->addArgument("--stop-on-copy");
                proc->addArgument(filename);
                return execCommand(SC_APPEND_USER_PASS, &out_txt);
}

int Svn::status() {
        common("status");
        proc->addArgument(caller->wd);
        proc->addArgument("--verbose");
        return execCommand(SC_APPEND_USER_PASS | SC_WAIT);
}

int Svn::info(const QString& filename, QStringList& out_txt, bool hideOutput) {
        common("info");
        proc->addArgument(filename);
        if (hideOutput)
                return execCommand(SC_HIDE, &out_txt);
        else
                return execCommand(0, &out_txt);
}

int Svn::commit(const QString& wd, QString msg) {
        common("commit");

        if (msg == "")
                msg = "nomsg";
        proc->addArgument("-m");
        proc->addArgument(msg);
        if (wd != "")
                proc->addArgument(wd);
        return execCommand(SC_REFRESH | SC_WAIT | SC_APPEND_USER_PASS);
}

int Svn::cleanup(QString& wd) {
        common("cleanup");
        if (wd != "")
                proc->addArgument(wd);
        return execCommand(SC_WAIT);
}

int Svn::revert(const QString& filename, bool recursive) {
        common("revert");
        if (recursive) 
                proc->addArgument("--recursive");
        if (filename != "") 
                proc->addArgument(filename);
        return execCommand(SC_REFRESH | SC_WAIT);
}

int Svn::resolve(const QString& filename) {
        common("resolved");
        if (filename != "")
                proc->addArgument(filename);
        return execCommand(SC_REFRESH | SC_WAIT);
}

int Svn::add(const QString& filename, bool recursive) {
        common("add");
        if (!recursive)
                proc->addArgument("-N");
        proc->addArgument(filename);
        return execCommand(SC_REFRESH | SC_WAIT);
}

int Svn::del(const QString filename) {
        common("delete");
        proc->addArgument(filename);
        return execCommand(SC_REFRESH | SC_APPEND_USER_PASS | SC_WAIT);
}

int Svn::copy(QString& src, const QString &dst, const QString& msg, const QString& rev) {
        common("copy");
        proc->addArgument(src);
        proc->addArgument(dst);
        proc->addArgument("-m");
        if (msg == "")
                proc->addArgument("\"copied\"");
        else
                proc->addArgument(msg);
        if (rev != "") {
                proc->addArgument("-r");
                proc->addArgument(rev);
        }
        return execCommand(SC_REFRESH | SC_APPEND_USER_PASS | SC_WAIT);
}

int Svn::move(const QString& src, const QString &dst, const QString& msg, const QString& rev) {
        common("move");
        proc->addArgument(src);
        proc->addArgument(dst);
        proc->addArgument("-m");
        if (msg == "")
                proc->addArgument("\"moved\"");
        else
                proc->addArgument(msg);
        if (rev != "") {
                proc->addArgument("-r");
                proc->addArgument(rev);
        }
        return execCommand(SC_REFRESH | SC_APPEND_USER_PASS | SC_WAIT);
}

int Svn::switch_cmd(const QString& url, const QString &rev, bool non_recursive) {
        common("switch");
        if (rev != "") {
                proc->addArgument("-r");
                proc->addArgument(rev);
        }
        if (non_recursive)
                proc->addArgument("--non-recursive");
        proc->addArgument(url);
        return execCommand(SC_REFRESH | SC_APPEND_USER_PASS | SC_WAIT);
}

int Svn::merge(const QString& file_dir_name, const QString& first, const QString &second,
                                const QString& wcpath, bool use_rev, bool non_recursive, bool dryrun) {
        common("merge");
        if (non_recursive)
                proc->addArgument("--non-recursive");
        if (dryrun)
                proc->addArgument("--dry-run");
        if (use_rev) {
                proc->addArgument("-r");
                proc->addArgument(first+":"+second);
                proc->addArgument(file_dir_name);
        }
        else {
                proc->addArgument(first);
                proc->addArgument(second);
        }
        if (!wcpath.isEmpty()) 
                proc->addArgument(wcpath);
        return execCommand(SC_REFRESH | SC_WAIT);
}

int Svn::cat(const QString& filename, const QString& rev, QStringList& out_txt) {
        common("cat");
        proc->addArgument(filename);
        if (rev != "") {
                proc->addArgument("-r");
                proc->addArgument(rev);
        }
        return execCommand(SC_APPEND_USER_PASS, &out_txt);
}

int Svn::blame(const QString& filename, const QString& rev, QStringList& out_txt) {
        common("blame");
        proc->addArgument(filename);
        if (rev != "") {
                proc->addArgument("-r");
                proc->addArgument(rev);
        }
        return execCommand(SC_APPEND_USER_PASS, &out_txt);
}

int Svn::checkout(const QString &rev, bool non_recursive) {
        common("checkout");
        proc->addArgument(caller->adress + caller->wd);
        proc->addArgument(caller->wd);

        if (rev != "") {
                proc->addArgument("-r");
                proc->addArgument(rev);
        }
        if (non_recursive)
                proc->addArgument("--non-recursive");
        proc->addArgument("--non-interactive");

        return execCommand(SC_REFRESH | SC_APPEND_USER_PASS | SC_WAIT);
}

int Svn::export_cmd(const QString& url, const QString& local_path, const QString &rev) {
        common("export");
        proc->addArgument(url);
        proc->addArgument(local_path);
        if (rev != "") {
                proc->addArgument("-r");
                proc->addArgument(rev);
        }
        return execCommand(SC_REFRESH | SC_APPEND_USER_PASS | SC_WAIT);
}

int Svn::import(const QString& url, const QString& local_path, QString msg,  bool non_recursive) {
        common("import");
        proc->addArgument(local_path);
        proc->addArgument(url);
        if (msg == "")
                msg = "nomsg";
        proc->addArgument("-m"); 
        proc->addArgument(msg);
        if (non_recursive)
                proc->addArgument("--non-recursive");
        return execCommand(SC_REFRESH | SC_APPEND_USER_PASS | SC_WAIT);
}

int Svn::mkdir(const QString& dir) {
        common("mkdir");
        proc->addArgument(dir);
        return execCommand(SC_REFRESH | SC_APPEND_USER_PASS | SC_WAIT);
}

int Svn::proplist(const QString& filename, const QString& rev, QStringList& out_txt) {
        common("proplist");
        proc->addArgument(filename);
        proc->addArgument("--verbose");
        if (!rev.isEmpty()) {
                proc->addArgument("-r");
                proc->addArgument(rev);
        }
        return execCommand(SC_WAIT | SC_APPEND_USER_PASS, &out_txt);
}

int Svn::propset(const QString& filename, const QString& rev, const QString& key, const QString &value) {
        common("propset");
        proc->addArgument(key);
        proc->addArgument(value);
        proc->addArgument(filename);
        if (rev != "") {
                proc->addArgument("-r");
                proc->addArgument(rev);
        }
        return execCommand(SC_WAIT | SC_APPEND_USER_PASS);
}

int Svn::propdel(const QString& filename, const QString& rev, const QString& key) {
        common("propdel");
        proc->addArgument(key);
        proc->addArgument(filename);
        if (rev != "") {
                proc->addArgument("-r");
                proc->addArgument(rev);
        }
        return execCommand(SC_WAIT | SC_APPEND_USER_PASS);
}

int Svn::list(const QString& url, const QString& rev, QStringList& out_txt, bool is_hide,
                        bool recursive, bool dont_change_cursor) {
        common("list");
        proc->addArgument(url);
        if (recursive)
                proc->addArgument("--recursive");
        proc->addArgument("--verbose");
        if (rev != "") {
                proc->addArgument("-r");
                proc->addArgument(rev);
        }
        return execCommand(SC_WAIT | SC_APPEND_USER_PASS | (dont_change_cursor ? SC_DISABLE_CURSOR_CHANGE : 0) | (is_hide ? SC_HIDE : 0), &out_txt);
}

void Svn::setSvn(QString svn){
        svn_ = svn;
}

int Svn::getLastRev() {
        QStringList infoOutput;
        if (info(caller->adress + caller->wd + "/prop.graphml", infoOutput,true))
                info(caller->wd + "/prop.graphml", infoOutput,true);
        infoOutput = infoOutput.grep("Revision");
        QString stemp = infoOutput.first();
        stemp = stemp.right( stemp.length() - 10);
        return stemp.toInt();
}



void Svn::readFromStdout() {
        while (proc->canReadLineStdout()) {
                QString src_msg = proc->readLineStdout();
                QString str = QTextCodec::codecForLocale()->toUnicode(src_msg);
                if(!str.isNull()){
                        if (show_enable_)
                                out_win_->append(QString("<font color=black>") + str + QString("</font>") );
                        out_text_.push_back(str);
                }
        }
}

void Svn::readFromStderr() {     
        while (proc->canReadLineStderr()) {
                QString str = QTextCodec::codecForLocale()->toUnicode(proc->readLineStderr());
                out_win_->append(QString("<font color=red>") + str + QString("</font>") );
                if (!disable_cursor_change_) 
                        QApplication::restoreOverrideCursor();
        }
}

void Svn::procFinished() {
        parent_->blockSignals(false);   
        if (!disable_cursor_change_) 
                QApplication::restoreOverrideCursor();
        if (!is_hide_all_) {
                int ret_code = proc->exitStatus();
                char ret_code_buff[64];
                if (ret_code == 0)
                        sprintf(ret_code_buff, "<font color=darkgreen>successfully (%d)</font>", ret_code);
                else
                        sprintf(ret_code_buff, "<font color=darkred>error (%d)</font>", ret_code);
                out_win_->append(ret_code_buff);
        }
        if (is_refreshable_command_)
                needs_refresh_ = true;
        is_ready_for_last_command_ = true;        
}

QString Svn::getLastCommand() {
        if (is_ready_for_last_command_) {
                QStringList args = proc->arguments();
                if (args.empty())
                        return "";
                else {
                        is_ready_for_last_command_ = false;
                        return args[1];
                }
        }
        else
                return "";
}


int Svn::execCommand(unsigned int flags, QStringList* out_list) {
        disable_cursor_change_ = (flags & SC_DISABLE_CURSOR_CHANGE);

        if (!disable_cursor_change_) 
                QApplication::setOverrideCursor( QCursor(Qt::WaitCursor) );
        is_refreshable_command_ = (flags & SC_REFRESH);

        if (flags & SC_APPEND_USER_PASS) {
                proc->addArgument("--username");
                proc->addArgument(caller->login());
                proc->addArgument("--password");
                proc->addArgument(caller->password());
                proc->addArgument("--non-interactive");
        }
        is_hide_all_ = (flags & SC_HIDE);

        if (!is_hide_all_ ) {
                QString svn_cmd = showCommand();
        }

        show_enable_ = (!out_list && !is_hide_all_);
        out_text_.clear();
        qApp->processEvents();

        proc->setWorkingDirectory(qApp->applicationDirPath());

        if (!proc->start()) {
                out_text_.append(tr("can't fork the process"));

                if (!disable_cursor_change_) 
                        QApplication::restoreOverrideCursor();
                return 1;
        }

        parent_->blockSignals(true);
        if (out_list || (flags & SC_WAIT) ) {

                while (proc->isRunning()) {
                        qApp->processEvents(QEventLoop::ExcludeUserInput);
                }

                if (!disable_cursor_change_) 
                        QApplication::restoreOverrideCursor();
        }

        if (out_list)
                *out_list = out_text_;

        show_enable_ = true;
        int ret_code = proc->exitStatus();
        return ret_code;
}

QString Svn::showCommand() {
        QStringList args = proc->arguments();
        QStringList::Iterator it = args.begin();
        QString out_str = "<font color=navy>";
        QString curr_str, prev_arg;
        int arg_num =0;
        while ( it != args.end() ) {
                if (arg_num && prev_arg == QString("--password") )
                        curr_str = "******";
                else
                        curr_str = (*it);
                if (arg_num++ == 1)
                        out_str = out_str + curr_str + "</font> ";
                else
                        out_str = out_str + curr_str + " ";
                ++it;
                prev_arg = curr_str;
        }
        out_win_->append(out_str);
        return out_str;
}