src/VCBackend.cpp

   1 /**
   2  * \file VCBackend.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Lars Gullik Bjønnes
   7  *
   8  * Full author contact details are available in file CREDITS.
   9  */
  10
  11 #include <config.h>
  12
  13 #include "VCBackend.h"
  14 #include "Buffer.h"
  15 #include "LyXFunc.h"
  16 #include "FuncRequest.h"
  17
  18 #include "frontends/alert.h"
  19 #include "frontends/Application.h"
  20
  21 #include "support/debug.h"
  22 #include "support/filetools.h"
  23 #include "support/gettext.h"
  24 #include "support/lstrings.h"
  25 #include "support/Path.h"
  26 #include "support/Systemcall.h"
  27
  28 #include <boost/regex.hpp>
  29
  30 #include <fstream>
  31
  32 using namespace std;
  33 using namespace lyx::support;
  34
  35 using boost::regex;
  36 using boost::regex_match;
  37 using boost::smatch;
  38
  39 namespace lyx {
  40
  41
  42 int VCS::doVCCommandCall(string const & cmd, FileName const & path)
  43 {
  44         LYXERR(Debug::LYXVC, "doVCCommandCall: " << cmd);
  45         Systemcall one;
  46         support::PathChanger p(path);
  47         return one.startscript(Systemcall::Wait, cmd, false);
  48 }
  49
  50
  51 int VCS::doVCCommand(string const & cmd, FileName const & path)
  52 {
  53         if (owner_)
  54                 owner_->setBusy(true);
  55
  56         int const ret = doVCCommandCall(cmd, path);
  57
  58         if (owner_)
  59                 owner_->setBusy(false);
  60         if (ret)
  61                 frontend::Alert::error(_("Revision control error."),
  62                         bformat(_("Some problem occured while running the command:\n"
  63                                   "'%1$s'."),
  64                         from_utf8(cmd)));
  65         return ret;
  66 }
  67
  68
  69 /////////////////////////////////////////////////////////////////////
  70 //
  71 // RCS
  72 //
  73 /////////////////////////////////////////////////////////////////////
  74
  75 RCS::RCS(FileName const & m)
  76 {
  77         master_ = m;
  78         scanMaster();
  79 }
  80
  81
  82 FileName const RCS::findFile(FileName const & file)
  83 {
  84         // Check if *,v exists.
  85         FileName tmp(file.absFilename() + ",v");
  86         LYXERR(Debug::LYXVC, "LyXVC: Checking if file is under rcs: " << tmp);
  87         if (tmp.isReadableFile()) {
  88                 LYXERR(Debug::LYXVC, "Yes, " << file << " is under rcs.");
  89                 return tmp;
  90         }
  91
  92         // Check if RCS/*,v exists.
  93         tmp = FileName(addName(addPath(onlyPath(file.absFilename()), "RCS"), file.absFilename()) + ",v");
  94         LYXERR(Debug::LYXVC, "LyXVC: Checking if file is under rcs: " << tmp);
  95         if (tmp.isReadableFile()) {
  96                 LYXERR(Debug::LYXVC, "Yes, " << file << " is under rcs.");
  97                 return tmp;
  98         }
  99
 100         return FileName();
 101 }
 102
 103
 104 void RCS::retrieve(FileName const & file)
 105 {
 106         LYXERR(Debug::LYXVC, "LyXVC::RCS: retrieve.\n\t" << file);
 107         doVCCommandCall("co -q -r " + quoteName(file.toFilesystemEncoding()),
 108                          FileName());
 109 }
 110
 111
 112 void RCS::scanMaster()
 113 {
 114         if (master_.empty())
 115                 return;
 116
 117         LYXERR(Debug::LYXVC, "LyXVC::RCS: scanMaster: " << master_);
 118
 119         ifstream ifs(master_.toFilesystemEncoding().c_str());
 120
 121         string token;
 122         bool read_enough = false;
 123
 124         while (!read_enough && ifs >> token) {
 125                 LYXERR(Debug::LYXVC, "LyXVC::scanMaster: current lex text: `"
 126                         << token << '\'');
 127
 128                 if (token.empty())
 129                         continue;
 130                 else if (token == "head") {
 131                         // get version here
 132                         string tmv;
 133                         ifs >> tmv;
 134                         tmv = rtrim(tmv, ";");
 135                         version_ = tmv;
 136                         LYXERR(Debug::LYXVC, "LyXVC: version found to be " << tmv);
 137                 } else if (contains(token, "access")
 138                            || contains(token, "symbols")
 139                            || contains(token, "strict")) {
 140                         // nothing
 141                 } else if (contains(token, "locks")) {
 142                         // get locker here
 143                         if (contains(token, ';')) {
 144                                 locker_ = "Unlocked";
 145                                 vcstatus = UNLOCKED;
 146                                 continue;
 147                         }
 148                         string tmpt;
 149                         string s1;
 150                         string s2;
 151                         do {
 152                                 ifs >> tmpt;
 153                                 s1 = rtrim(tmpt, ";");
 154                                 // tmp is now in the format <user>:<version>
 155                                 s1 = split(s1, s2, ':');
 156                                 // s2 is user, and s1 is version
 157                                 if (s1 == version_) {
 158                                         locker_ = s2;
 159                                         vcstatus = LOCKED;
 160                                         break;
 161                                 }
 162                         } while (!contains(tmpt, ';'));
 163
 164                 } else if (token == "comment") {
 165                         // we don't need to read any further than this.
 166                         read_enough = true;
 167                 } else {
 168                         // unexpected
 169                         LYXERR(Debug::LYXVC, "LyXVC::scanMaster(): unexpected token");
 170                 }
 171         }
 172 }
 173
 174
 175 void RCS::registrer(string const & msg)
 176 {
 177         string cmd = "ci -q -u -i -t-\"";
 178         cmd += msg;
 179         cmd += "\" ";
 180         cmd += quoteName(onlyFilename(owner_->absFileName()));
 181         doVCCommand(cmd, FileName(owner_->filePath()));
 182 }
 183
 184
 185 string RCS::checkIn(string const & msg)
 186 {
 187         int ret = doVCCommand("ci -q -u -m\"" + msg + "\" "
 188                     + quoteName(onlyFilename(owner_->absFileName())),
 189                     FileName(owner_->filePath()));
 190         return ret ? string() : "RCS: Proceeded";
 191 }
 192
 193
 194 bool RCS::checkInEnabled()
 195 {
 196         return owner_ && !owner_->isReadonly();
 197 }
 198
 199
 200 string RCS::checkOut()
 201 {
 202         owner_->markClean();
 203         int ret = doVCCommand("co -q -l " + quoteName(onlyFilename(owner_->absFileName())),
 204                     FileName(owner_->filePath()));
 205         return ret ? string() : "RCS: Proceeded";
 206 }
 207
 208
 209 bool RCS::checkOutEnabled()
 210 {
 211         return owner_ && owner_->isReadonly();
 212 }
 213
 214
 215 string RCS::repoUpdate()
 216 {
 217         lyxerr << "Sorry, not implemented." << endl;
 218         return string();
 219 }
 220
 221
 222 bool RCS::repoUpdateEnabled()
 223 {
 224         return false;
 225 }
 226
 227
 228 string RCS::lockingToggle()
 229 {
 230         lyxerr << "Sorry, not implemented." << endl;
 231         return string();
 232 }
 233
 234
 235 bool RCS::lockingToggleEnabled()
 236 {
 237         return false;
 238 }
 239
 240
 241 void RCS::revert()
 242 {
 243         doVCCommand("co -f -u" + version() + " "
 244                     + quoteName(onlyFilename(owner_->absFileName())),
 245                     FileName(owner_->filePath()));
 246         // We ignore changes and just reload!
 247         owner_->markClean();
 248 }
 249
 250
 251 void RCS::undoLast()
 252 {
 253         LYXERR(Debug::LYXVC, "LyXVC: undoLast");
 254         doVCCommand("rcs -o" + version() + " "
 255                     + quoteName(onlyFilename(owner_->absFileName())),
 256                     FileName(owner_->filePath()));
 257 }
 258
 259
 260 bool RCS::undoLastEnabled()
 261 {
 262         return true;
 263 }
 264
 265
 266 void RCS::getLog(FileName const & tmpf)
 267 {
 268         doVCCommand("rlog " + quoteName(onlyFilename(owner_->absFileName()))
 269                     + " > " + quoteName(tmpf.toFilesystemEncoding()),
 270                     FileName(owner_->filePath()));
 271 }
 272
 273
 274 bool RCS::toggleReadOnlyEnabled()
 275 {
 276         // This got broken somewhere along lfuns dispatch reorganization.
 277         // reloadBuffer would be needed after this, but thats problematic
 278         // since we are inside Buffer::dispatch.
 279         // return true;
 280         return false;
 281 }
 282
 283
 284 /////////////////////////////////////////////////////////////////////
 285 //
 286 // CVS
 287 //
 288 /////////////////////////////////////////////////////////////////////
 289
 290 CVS::CVS(FileName const & m, FileName const & f)
 291 {
 292         master_ = m;
 293         file_ = f;
 294         scanMaster();
 295 }
 296
 297
 298 FileName const CVS::findFile(FileName const & file)
 299 {
 300         // First we look for the CVS/Entries in the same dir
 301         // where we have file.
 302         FileName const entries(onlyPath(file.absFilename()) + "/CVS/Entries");
 303         string const tmpf = '/' + onlyFilename(file.absFilename()) + '/';
 304         LYXERR(Debug::LYXVC, "LyXVC: Checking if file is under cvs in `" << entries
 305                              << "' for `" << tmpf << '\'');
 306         if (entries.isReadableFile()) {
 307                 // Ok we are at least in a CVS dir. Parse the CVS/Entries
 308                 // and see if we can find this file. We do a fast and
 309                 // dirty parse here.
 310                 ifstream ifs(entries.toFilesystemEncoding().c_str());
 311                 string line;
 312                 while (getline(ifs, line)) {
 313                         LYXERR(Debug::LYXVC, "\tEntries: " << line);
 314                         if (contains(line, tmpf))
 315                                 return entries;
 316                 }
 317         }
 318         return FileName();
 319 }
 320
 321
 322 void CVS::scanMaster()
 323 {
 324         LYXERR(Debug::LYXVC, "LyXVC::CVS: scanMaster. \n     Checking: " << master_);
 325         // Ok now we do the real scan...
 326         ifstream ifs(master_.toFilesystemEncoding().c_str());
 327         string tmpf = '/' + onlyFilename(file_.absFilename()) + '/';
 328         LYXERR(Debug::LYXVC, "\tlooking for `" << tmpf << '\'');
 329         string line;
 330         static regex const reg("/(.*)/(.*)/(.*)/(.*)/(.*)");
 331         while (getline(ifs, line)) {
 332                 LYXERR(Debug::LYXVC, "\t  line: " << line);
 333                 if (contains(line, tmpf)) {
 334                         // Ok extract the fields.
 335                         smatch sm;
 336
 337                         regex_match(line, sm, reg);
 338
 339                         //sm[0]; // whole matched string
 340                         //sm[1]; // filename
 341                         version_ = sm.str(2);
 342                         string const file_date = sm.str(3);
 343
 344                         //sm[4]; // options
 345                         //sm[5]; // tag or tagdate
 346                         // FIXME: must double check file is stattable/existing
 347                         time_t mod = file_.lastModified();
 348                         string mod_date = rtrim(asctime(gmtime(&mod)), "\n");
 349                         LYXERR(Debug::LYXVC, "Date in Entries: `" << file_date
 350                                 << "'\nModification date of file: `" << mod_date << '\'');
 351                         //FIXME this whole locking bussiness is not working under cvs and the machinery
 352                         // conforms to the ci usage, not cvs.
 353                         if (file_date == mod_date) {
 354                                 locker_ = "Unlocked";
 355                                 vcstatus = UNLOCKED;
 356                         } else {
 357                                 // Here we should also to some more checking
 358                                 // to see if there are conflicts or not.
 359                                 locker_ = "Locked";
 360                                 vcstatus = LOCKED;
 361                         }
 362                         break;
 363                 }
 364         }
 365 }
 366
 367
 368 void CVS::registrer(string const & msg)
 369 {
 370         doVCCommand("cvs -q add -m \"" + msg + "\" "
 371                     + quoteName(onlyFilename(owner_->absFileName())),
 372                     FileName(owner_->filePath()));
 373 }
 374
 375
 376 string CVS::checkIn(string const & msg)
 377 {
 378         int ret = doVCCommand("cvs -q commit -m \"" + msg + "\" "
 379                     + quoteName(onlyFilename(owner_->absFileName())),
 380                     FileName(owner_->filePath()));
 381         return ret ? string() : "CVS: Proceeded";
 382 }
 383
 384
 385 bool CVS::checkInEnabled()
 386 {
 387         return true;
 388 }
 389
 390
 391 string CVS::checkOut()
 392 {
 393         // cvs update or perhaps for cvs this should be a noop
 394         // we need to detect conflict (eg "C" in output)
 395         // before we can do this.
 396         lyxerr << "Sorry, not implemented." << endl;
 397         return string();
 398 }
 399
 400
 401 bool CVS::checkOutEnabled()
 402 {
 403         return false;
 404 }
 405
 406
 407 string CVS::repoUpdate()
 408 {
 409         lyxerr << "Sorry, not implemented." << endl;
 410         return string();
 411 }
 412
 413
 414 bool CVS::repoUpdateEnabled()
 415 {
 416         return false;
 417 }
 418
 419
 420 string CVS::lockingToggle()
 421 {
 422         lyxerr << "Sorry, not implemented." << endl;
 423         return string();
 424 }
 425
 426
 427 bool CVS::lockingToggleEnabled()
 428 {
 429         return false;
 430 }
 431
 432
 433 void CVS::revert()
 434 {
 435         // Reverts to the version in CVS repository and
 436         // gets the updated version from the repository.
 437         string const fil = quoteName(onlyFilename(owner_->absFileName()));
 438         // This is sensitive operation, so at lest some check about
 439         // existence of cvs program and its file
 440         if (doVCCommand("cvs log "+ fil, FileName(owner_->filePath())))
 441                 return;
 442         FileName f(owner_->absFileName());
 443         f.removeFile();
 444         doVCCommand("cvs update " + fil,
 445                     FileName(owner_->filePath()));
 446         owner_->markClean();
 447 }
 448
 449
 450 void CVS::undoLast()
 451 {
 452         // merge the current with the previous version
 453         // in a reverse patch kind of way, so that the
 454         // result is to revert the last changes.
 455         lyxerr << "Sorry, not implemented." << endl;
 456 }
 457
 458
 459 bool CVS::undoLastEnabled()
 460 {
 461         return false;
 462 }
 463
 464
 465 void CVS::getLog(FileName const & tmpf)
 466 {
 467         doVCCommand("cvs log " + quoteName(onlyFilename(owner_->absFileName()))
 468                     + " > " + quoteName(tmpf.toFilesystemEncoding()),
 469                     FileName(owner_->filePath()));
 470 }
 471
 472
 473 bool CVS::toggleReadOnlyEnabled()
 474 {
 475         return false;
 476 }
 477
 478 /////////////////////////////////////////////////////////////////////
 479 //
 480 // SVN
 481 //
 482 /////////////////////////////////////////////////////////////////////
 483
 484 SVN::SVN(FileName const & m, FileName const & f)
 485 {
 486         owner_ = 0;
 487         master_ = m;
 488         file_ = f;
 489         locked_mode_ = 0;
 490         scanMaster();
 491 }
 492
 493
 494 FileName const SVN::findFile(FileName const & file)
 495 {
 496         // First we look for the .svn/entries in the same dir
 497         // where we have file.
 498         FileName const entries(onlyPath(file.absFilename()) + "/.svn/entries");
 499         string const tmpf = onlyFilename(file.absFilename());
 500         LYXERR(Debug::LYXVC, "LyXVC: Checking if file is under svn in `" << entries
 501                              << "' for `" << tmpf << '\'');
 502         if (entries.isReadableFile()) {
 503                 // Ok we are at least in a SVN dir. Parse the .svn/entries
 504                 // and see if we can find this file. We do a fast and
 505                 // dirty parse here.
 506                 ifstream ifs(entries.toFilesystemEncoding().c_str());
 507                 string line, oldline;
 508                 while (getline(ifs, line)) {
 509                         if (line == "dir" || line == "file")
 510                                 LYXERR(Debug::LYXVC, "\tEntries: " << oldline);
 511                         if (oldline == tmpf && line == "file")
 512                                 return entries;
 513                         oldline = line;
 514                 }
 515         }
 516         return FileName();
 517 }
 518
 519
 520 void SVN::scanMaster()
 521 {
 522         locker_.clear();
 523         vcstatus = NOLOCKING;
 524         if (checkLockMode()) {
 525                 if (isLocked()) {
 526                         locker_ = "Locked";
 527                         vcstatus = LOCKED;
 528                 } else {
 529                         locker_ = "Unlocked";
 530                         vcstatus = LOCKED;
 531                 }
 532         }
 533 }
 534
 535
 536 bool SVN::checkLockMode()
 537 {
 538         FileName tmpf = FileName::tempName("lyxvcout");
 539         if (tmpf.empty()){
 540                 LYXERR(Debug::LYXVC, "Could not generate logfile " << tmpf);
 541                 return N_("Error: Could not generate logfile.");
 542         }
 543
 544         LYXERR(Debug::LYXVC, "Detecting locking mode...");
 545         if (doVCCommandCall("svn proplist " + quoteName(file_.onlyFileName())
 546                     + " > " + quoteName(tmpf.toFilesystemEncoding()),
 547                     file_.onlyPath()))
 548                 return false;
 549
 550         ifstream ifs(tmpf.toFilesystemEncoding().c_str());
 551         string line;
 552         bool ret = false;
 553
 554         while (ifs) {
 555                 getline(ifs, line);
 556                 LYXERR(Debug::LYXVC, line);
 557                 if (contains(line, "svn:needs-lock"))
 558                         ret = true;
 559         }
 560         LYXERR(Debug::LYXVC, "Locking enabled: " << ret);
 561         ifs.close();
 562         locked_mode_ = ret;
 563         return ret;
 564
 565 }
 566
 567
 568 bool SVN::isLocked() const
 569 {
 570         //refresh file info
 571         FileName file(file_.absFilename());
 572         return !file.isReadOnly();
 573 }
 574
 575
 576 void SVN::registrer(string const & /*msg*/)
 577 {
 578         doVCCommand("svn add -q " + quoteName(onlyFilename(owner_->absFileName())),
 579                     FileName(owner_->filePath()));
 580 }
 581
 582
 583 string SVN::checkIn(string const & msg)
 584 {
 585         FileName tmpf = FileName::tempName("lyxvcout");
 586         if (tmpf.empty()){
 587                 LYXERR(Debug::LYXVC, "Could not generate logfile " << tmpf);
 588                 return N_("Error: Could not generate logfile.");
 589         }
 590
 591         doVCCommand("svn commit -m \"" + msg + "\" "
 592                     + quoteName(onlyFilename(owner_->absFileName()))
 593                     + " > " + quoteName(tmpf.toFilesystemEncoding()),
 594                     FileName(owner_->filePath()));
 595
 596         string log;
 597         string res = scanLogFile(tmpf, log);
 598         if (!res.empty())
 599                 frontend::Alert::error(_("Revision control error."),
 600                                 _("Error when committing to repository.\n"
 601                                 "You have to manually resolve the problem.\n"
 602                                 "After pressing OK, LyX will reopen the document."));
 603         else
 604                 fileLock(false, tmpf, log);
 605
 606         tmpf.erase();
 607         return log.empty() ? string() : "SVN: " + log;
 608 }
 609
 610
 611 bool SVN::checkInEnabled()
 612 {
 613         if (locked_mode_)
 614                 return isLocked();
 615         else
 616                 return true;
 617 }
 618
 619
 620 // FIXME Correctly return code should be checked instead of this.
 621 // This would need another solution than just plain startscript.
 622 // Hint from Andre': QProcess::readAllStandardError()...
 623 string SVN::scanLogFile(FileName const & f, string & status)
 624 {
 625         ifstream ifs(f.toFilesystemEncoding().c_str());
 626         string line;
 627
 628         while (ifs) {
 629                 getline(ifs, line);
 630                 lyxerr << line << "\n";
 631                 if (!line.empty()) status += line + "; ";
 632                 if (prefixIs(line, "C ") || contains(line, "Commit failed")) {
 633                         ifs.close();
 634                         return line;
 635                 }
 636                 if (contains(line, "svn:needs-lock")) {
 637                         ifs.close();
 638                         return line;
 639                 }
 640         }
 641         ifs.close();
 642         return string();
 643 }
 644
 645
 646 void SVN::fileLock(bool lock, FileName const & tmpf, string &status)
 647 {
 648         if (!locked_mode_ || (isLocked() == lock))
 649                 return;
 650
 651         string arg = lock ? "lock " : "unlock ";
 652         doVCCommand("svn "+ arg + quoteName(onlyFilename(owner_->absFileName()))
 653                     + " > " + quoteName(tmpf.toFilesystemEncoding()),
 654                     FileName(owner_->filePath()));
 655
 656         // Lock error messages go unfortunately on stderr and are unreachible this way.
 657         ifstream ifs(tmpf.toFilesystemEncoding().c_str());
 658         string line;
 659         while (ifs) {
 660                 getline(ifs, line);
 661                 if (!line.empty()) status += line + "; ";
 662         }
 663         ifs.close();
 664
 665         if (!isLocked() && lock)
 666                 frontend::Alert::error(_("Revision control error."),
 667                         _("Error when acquiring write lock.\n"
 668                         "Most probably another user is editing\n"
 669                         "the current document now!\n"
 670                         "Also check the access to the repository."));
 671         if (isLocked() && !lock)
 672                 frontend::Alert::error(_("Revision control error."),
 673                         _("Error when releasing write lock.\n"
 674                         "Check the access to the repository."));
 675 }
 676
 677
 678 string SVN::checkOut()
 679 {
 680         FileName tmpf = FileName::tempName("lyxvcout");
 681         if (tmpf.empty()) {
 682                 LYXERR(Debug::LYXVC, "Could not generate logfile " << tmpf);
 683                 return N_("Error: Could not generate logfile.");
 684         }
 685
 686         doVCCommand("svn update " + quoteName(onlyFilename(owner_->absFileName()))
 687                     + " > " + quoteName(tmpf.toFilesystemEncoding()),
 688                     FileName(owner_->filePath()));
 689
 690         string log;
 691         string res = scanLogFile(tmpf, log);
 692         if (!res.empty())
 693                 frontend::Alert::error(_("Revision control error."),
 694                         bformat(_("Error when updating from repository.\n"
 695                                 "You have to manually resolve the conflicts NOW!\n'%1$s'.\n\n"
 696                                 "After pressing OK, LyX will try to reopen resolved document."),
 697                         from_local8bit(res)));
 698
 699         fileLock(true, tmpf, log);
 700
 701         tmpf.erase();
 702         return log.empty() ? string() : "SVN: " + log;
 703 }
 704
 705
 706 bool SVN::checkOutEnabled()
 707 {
 708         if (locked_mode_)
 709                 return !isLocked();
 710         else
 711                 return true;
 712 }
 713
 714
 715 string SVN::repoUpdate()
 716 {
 717         FileName tmpf = FileName::tempName("lyxvcout");
 718         if (tmpf.empty()) {
 719                 LYXERR(Debug::LYXVC, "Could not generate logfile " << tmpf);
 720                 return N_("Error: Could not generate logfile.");
 721         }
 722
 723         doVCCommand("svn diff " + quoteName(owner_->filePath())
 724         + " > " + quoteName(tmpf.toFilesystemEncoding()),
 725         FileName(owner_->filePath()));
 726         docstring res = tmpf.fileContents("UTF-8");
 727         if (!res.empty()) {
 728                 LYXERR(Debug::LYXVC, "Diff detected:\n" << res);
 729                 docstring const file = from_utf8(owner_->filePath());
 730                 docstring text = bformat(_("There were detected changes "
 731                                 "in the working directory:\n%1$s\n\n"
 732                                 "In case of file conflict version of the local directory files "
 733                                 "will be preferred."
 734                                 "\n\nContinue?"), file);
 735                 int ret = frontend::Alert::prompt(_("Changes detected"),
 736                                 text, 0, 1, _("&Yes"), _("&No"), _("View &Log ..."));
 737                 if (ret == 2 ) {
 738                         dispatch(FuncRequest(LFUN_DIALOG_SHOW, "file " + tmpf.absFilename()));
 739                         ret = frontend::Alert::prompt(_("Changes detected"),
 740                                 text, 0, 1, _("&Yes"), _("&No"));
 741                         hideDialogs("file", 0);
 742                 }
 743                 if (ret == 1 ) {
 744                         tmpf.erase();
 745                         return string();
 746                 }
 747         }
 748
 749         // Reverting looks too harsh, see bug #6255.
 750         // doVCCommand("svn revert -R " + quoteName(owner_->filePath())
 751         // + " > " + quoteName(tmpf.toFilesystemEncoding()),
 752         // FileName(owner_->filePath()));
 753         // res = "Revert log:\n" + tmpf.fileContents("UTF-8");
 754         doVCCommand("svn update --accept mine-full " + quoteName(owner_->filePath())
 755         + " > " + quoteName(tmpf.toFilesystemEncoding()),
 756         FileName(owner_->filePath()));
 757         res += "Update log:\n" + tmpf.fileContents("UTF-8");
 758
 759         LYXERR(Debug::LYXVC, res);
 760         tmpf.erase();
 761         return to_utf8(res);
 762 }
 763
 764
 765 bool SVN::repoUpdateEnabled()
 766 {
 767         return true;
 768 }
 769
 770
 771 string SVN::lockingToggle()
 772 {
 773         FileName tmpf = FileName::tempName("lyxvcout");
 774         if (tmpf.empty()) {
 775                 LYXERR(Debug::LYXVC, "Could not generate logfile " << tmpf);
 776                 return N_("Error: Could not generate logfile.");
 777         }
 778
 779         int ret = doVCCommand("svn proplist " + quoteName(onlyFilename(owner_->absFileName()))
 780                     + " > " + quoteName(tmpf.toFilesystemEncoding()),
 781                     FileName(owner_->filePath()));
 782         if (ret)
 783                 return string();
 784
 785         string log;
 786         string res = scanLogFile(tmpf, log);
 787         bool locking = contains(res, "svn:needs-lock");
 788         if (!locking)
 789                 ret = doVCCommand("svn propset svn:needs-lock ON "
 790                     + quoteName(onlyFilename(owner_->absFileName()))
 791                     + " > " + quoteName(tmpf.toFilesystemEncoding()),
 792                     FileName(owner_->filePath()));
 793         else
 794                 ret = doVCCommand("svn propdel svn:needs-lock "
 795                     + quoteName(onlyFilename(owner_->absFileName()))
 796                     + " > " + quoteName(tmpf.toFilesystemEncoding()),
 797                     FileName(owner_->filePath()));
 798         if (ret)
 799                 return string();
 800
 801         tmpf.erase();
 802         frontend::Alert::warning(_("VCN File Locking"),
 803                 (locking ? _("Locking property unset.") : _("Locking property set.")) + "\n"
 804                 + _("Do not forget to commit the locking property into the repository."),
 805                 true);
 806
 807         return string("SVN: ") +  N_("Locking property set.");
 808 }
 809
 810
 811 bool SVN::lockingToggleEnabled()
 812 {
 813         return true;
 814 }
 815
 816
 817 void SVN::revert()
 818 {
 819         // Reverts to the version in CVS repository and
 820         // gets the updated version from the repository.
 821         string const fil = quoteName(onlyFilename(owner_->absFileName()));
 822
 823         doVCCommand("svn revert -q " + fil,
 824                     FileName(owner_->filePath()));
 825         owner_->markClean();
 826 }
 827
 828
 829 void SVN::undoLast()
 830 {
 831         // merge the current with the previous version
 832         // in a reverse patch kind of way, so that the
 833         // result is to revert the last changes.
 834         lyxerr << "Sorry, not implemented." << endl;
 835 }
 836
 837
 838 bool SVN::undoLastEnabled()
 839 {
 840         return false;
 841 }
 842
 843
 844 void SVN::getLog(FileName const & tmpf)
 845 {
 846         doVCCommand("svn log " + quoteName(onlyFilename(owner_->absFileName()))
 847                     + " > " + quoteName(tmpf.toFilesystemEncoding()),
 848                     FileName(owner_->filePath()));
 849 }
 850
 851
 852 bool SVN::toggleReadOnlyEnabled()
 853 {
 854         return false;
 855 }
 856
 857
 858 } // namespace lyx