X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FVCBackend.cpp;h=753bd63890cb119e7545f1c66f5fc922b82221b3;hb=cb5dd33475e7cca472ead1fd3eac9f174b8b76ba;hp=efb223c8095215e7b63a6f0ae3e3a78c1c8b53aa;hpb=69dd56d6c4d85432c58cbafd5a6346df5c3d5c75;p=lyx.git

diff --git a/src/VCBackend.cpp b/src/VCBackend.cpp
index efb223c809..753bd63890 100644
--- a/src/VCBackend.cpp
+++ b/src/VCBackend.cpp
@@ -24,7 +24,7 @@
 #include "support/filetools.h"
 #include "support/gettext.h"
 #include "support/lstrings.h"
-#include "support/Path.h"
+#include "support/PathChanger.h"
 #include "support/Systemcall.h"
 #include "support/regex.h"
 
@@ -43,7 +43,7 @@ int VCS::doVCCommandCall(string const & cmd, FileName const & path)
 	LYXERR(Debug::LYXVC, "doVCCommandCall: " << cmd);
 	Systemcall one;
 	support::PathChanger p(path);
-	return one.startscript(Systemcall::Wait, cmd, false);
+	return one.startscript(Systemcall::Wait, cmd, string(), false);
 }
 
 
@@ -65,13 +65,64 @@ int VCS::doVCCommand(string const & cmd, FileName const & path, bool reportError
 }
 
 
+bool VCS::makeRCSRevision(string const &version, string &revis) const
+{
+	string rev = revis;
+	
+	if (isStrInt(rev)) {
+		int back = convert<int>(rev);
+		// if positive use as the last number in the whole revision string
+		if (back > 0) {
+			string base;
+			rsplit(version, base , '.' );
+			rev = base + "." + rev;
+		}
+		if (back == 0)
+			rev = version;
+		// we care about the last number from revision string
+		// in case of backward indexing
+		if (back < 0) {
+			string cur, base;
+			cur = rsplit(version, base , '.' );
+			if (!isStrInt(cur))
+				return false;
+			int want = convert<int>(cur) + back;
+			if (want <= 0)
+				return false;
+			
+			rev = base + "." + convert<string>(want);
+		}
+	}
+
+	revis = rev;
+	return true;
+}
+
+
+bool VCS::checkparentdirs(FileName const & file, std::string const & pathname)
+{
+	FileName dirname = file.onlyPath();
+	FileName tocheck = FileName(addName(dirname.absFileName(),pathname));
+	LYXERR(Debug::LYXVC, "check file: " << tocheck.absFileName());
+	bool result = tocheck.exists();
+	while ( !result && !dirname.empty() ) {
+		//this construct because of #8295
+		dirname = FileName(dirname.absFileName()).parentPath();
+		LYXERR(Debug::LYXVC, "check directory: " << dirname.absFileName());
+		tocheck = FileName(addName(dirname.absFileName(),pathname));
+		result = tocheck.exists();
+	}
+	return result;
+}
+
+	
 /////////////////////////////////////////////////////////////////////
 //
 // RCS
 //
 /////////////////////////////////////////////////////////////////////
 
-RCS::RCS(FileName const & m)
+RCS::RCS(FileName const & m, Buffer * b) : VCS(b)
 {
 	master_ = m;
 	scanMaster();
@@ -100,11 +151,12 @@ FileName const RCS::findFile(FileName const & file)
 }
 
 
-void RCS::retrieve(FileName const & file)
+bool RCS::retrieve(FileName const & file)
 {
 	LYXERR(Debug::LYXVC, "LyXVC::RCS: retrieve.\n\t" << file);
-	doVCCommandCall("co -q -r " + quoteName(file.toFilesystemEncoding()),
-			 FileName());
+	// The caller ensures that file does not exist, so no need to check that.
+	return doVCCommandCall("co -q -r " + quoteName(file.toFilesystemEncoding()),
+	                       FileName()) == 0;
 }
 
 
@@ -181,12 +233,50 @@ void RCS::registrer(string const & msg)
 }
 
 
-string RCS::checkIn(string const & msg)
+bool RCS::renameEnabled()
+{
+	return false;
+}
+
+
+string RCS::rename(support::FileName const & /*newFile*/, string const & /*msg*/)
+{
+	// not implemented, since a left-over file.lyx,v would be confusing.
+	return string();
+}
+
+
+bool RCS::copyEnabled()
+{
+	return true;
+}
+
+
+string RCS::copy(support::FileName const & newFile, string const & msg)
+{
+	// RCS has no real copy command, so we create a poor mans version
+	support::FileName const oldFile(owner_->absFileName());
+	if (!oldFile.copyTo(newFile))
+		return string();
+	FileName path(oldFile.onlyPath());
+	string relFile(to_utf8(newFile.relPath(path.absFileName())));
+	string cmd = "ci -q -u -i -t-\"";
+	cmd += msg;
+	cmd += "\" ";
+	cmd += quoteName(relFile);
+	return doVCCommand(cmd, path) ? string() : "RCS: Proceeded";
+}
+
+
+LyXVC::CommandResult RCS::checkIn(string const & msg, string & log)
 {
 	int ret = doVCCommand("ci -q -u -m\"" + msg + "\" "
 		    + quoteName(onlyFileName(owner_->absFileName())),
 		    FileName(owner_->filePath()));
-	return ret ? string() : "RCS: Proceeded";
+	if (ret)
+		return LyXVC::ErrorCommand;
+	log = "RCS: Proceeded";
+	return LyXVC::VCSuccess;
 }
 
 
@@ -195,9 +285,30 @@ bool RCS::checkInEnabled()
 	return owner_ && !owner_->isReadonly();
 }
 
+
 bool RCS::isCheckInWithConfirmation()
 {
-	//FIXME diff
+	// FIXME one day common getDiff for all backends
+	// docstring diff;
+	// if (getDiff(file, diff) && diff.empty())
+	//	return false;
+
+	FileName tmpf = FileName::tempName("lyxvcout");
+	if (tmpf.empty()) {
+		LYXERR(Debug::LYXVC, "Could not generate logfile " << tmpf);
+		return true;
+	}
+
+	doVCCommandCall("rcsdiff " + quoteName(owner_->absFileName())
+		    + " > " + quoteName(tmpf.toFilesystemEncoding()),
+		FileName(owner_->filePath()));
+
+	docstring diff = tmpf.fileContents("UTF-8");
+	tmpf.removeFile();
+
+	if (diff.empty())
+		return false;
+
 	return true;
 }
 
@@ -246,13 +357,15 @@ bool RCS::lockingToggleEnabled()
 }
 
 
-void RCS::revert()
+bool RCS::revert()
 {
-	doVCCommand("co -f -u" + version_ + " "
+	if (doVCCommand("co -f -u" + version_ + " "
 		    + quoteName(onlyFileName(owner_->absFileName())),
-		    FileName(owner_->filePath()));
+		    FileName(owner_->filePath())))
+		return false;
 	// We ignore changes and just reload!
 	owner_->markClean();
+	return true;
 }
 
 
@@ -291,51 +404,87 @@ bool RCS::toggleReadOnlyEnabled()
 	// This got broken somewhere along lfuns dispatch reorganization.
 	// reloadBuffer would be needed after this, but thats problematic
 	// since we are inside Buffer::dispatch.
-	// return true;
+	// return return status() != UNVERSIONED;
 	return false;
 }
 
+
 string RCS::revisionInfo(LyXVC::RevisionInfo const info)
 {
 	if (info == LyXVC::File)
 		return version_;
+	// fill the rest of the attributes for a single file
+	if (rev_date_cache_.empty())
+		if (!getRevisionInfo())
+			return string();
+
+	switch (info) {
+		case LyXVC::Author:
+			return rev_author_cache_;
+		case LyXVC::Date:
+			return rev_date_cache_;
+		case LyXVC::Time:
+			return rev_time_cache_;
+		default: ;
+	}
+
 	return string();
 }
 
 
-bool RCS::prepareFileRevision(string const &revis, string & f)
+bool RCS::getRevisionInfo()
 {
-	string rev = revis;
+	FileName tmpf = FileName::tempName("lyxvcout");
+	if (tmpf.empty()) {
+		LYXERR(Debug::LYXVC, "Could not generate logfile " << tmpf);
+		return false;
+	}
+	doVCCommand("rlog -r " + quoteName(onlyFileName(owner_->absFileName()))
+		+ " > " + quoteName(tmpf.toFilesystemEncoding()),
+		FileName(owner_->filePath()));
 
-	if (isStrInt(rev)) {
-		int back = convert<int>(rev);
-		// if positive use as the last number in the whole revision string
-		if (back > 0) {
-			string base;
-			rsplit(version_, base , '.' );
-			rev = base + "." + rev;
-		}
-		if (back == 0)
-			rev = version_;
-		// we care about the last number from revision string
-		// in case of backward indexing
-		if (back < 0) {
-			string cur, base;
-			cur = rsplit(version_, base , '.' );
-			if (!isStrInt(cur))
-				return false;
-			int want = convert<int>(cur) + back;
-			if (want <= 0)
-				return false;
+	if (tmpf.empty())
+		return false;
 
-			rev = base + "." + convert<string>(want);
+	ifstream ifs(tmpf.toFilesystemEncoding().c_str());
+	string line;
+
+	// we reached to the entry, i.e. after initial log message
+	bool entry=false;
+	// line with critical info, e.g:
+	//"date: 2011/07/02 11:02:54;  author: sanda;  state: Exp;  lines: +17 -2"
+	string result;
+
+	while (ifs) {
+		getline(ifs, line);
+		LYXERR(Debug::LYXVC, line);
+		if (entry && prefixIs(line, "date:")) {
+			result = line;
+			break;
 		}
+		if (prefixIs(line, "revision"))
+			entry = true;
 	}
+	if (result.empty())
+		return false;
+
+	rev_date_cache_ = token(result, ' ', 1);
+	rev_time_cache_ = rtrim(token(result, ' ', 2), ";");
+	rev_author_cache_ = trim(token(token(result, ';', 1), ':', 1));
+
+	return !rev_author_cache_.empty();
+}
+
+bool RCS::prepareFileRevision(string const &revis, string & f)
+{
+	string rev = revis;
+	if (!VCS::makeRCSRevision(version_, rev))
+		return false;
 
 	FileName tmpf = FileName::tempName("lyxvcrev_" + rev + "_");
 	if (tmpf.empty()) {
 		LYXERR(Debug::LYXVC, "Could not generate logfile " << tmpf);
-		return N_("Error: Could not generate logfile.");
+		return false;
 	}
 
 	doVCCommand("co -p" + rev + " "
@@ -362,10 +511,9 @@ bool RCS::prepareFileRevisionEnabled()
 //
 /////////////////////////////////////////////////////////////////////
 
-CVS::CVS(FileName const & m, FileName const & f)
+CVS::CVS(FileName const & m, Buffer * b) : VCS(b)
 {
 	master_ = m;
-	file_ = f;
 	have_rev_info_ = false;
 	scanMaster();
 }
@@ -400,11 +548,12 @@ void CVS::scanMaster()
 	LYXERR(Debug::LYXVC, "LyXVC::CVS: scanMaster. \n     Checking: " << master_);
 	// Ok now we do the real scan...
 	ifstream ifs(master_.toFilesystemEncoding().c_str());
-	string name = onlyFileName(file_.absFileName());
+	string name = onlyFileName(owner_->absFileName());
 	string tmpf = '/' + name + '/';
 	LYXERR(Debug::LYXVC, "\tlooking for `" << tmpf << '\'');
 	string line;
 	static regex const reg("/(.*)/(.*)/(.*)/(.*)/(.*)");
+	vcstatus = UNVERSIONED;
 	while (getline(ifs, line)) {
 		LYXERR(Debug::LYXVC, "\t  line: " << line);
 		if (contains(line, tmpf)) {
@@ -420,12 +569,13 @@ void CVS::scanMaster()
 
 			//sm[4]; // options
 			//sm[5]; // tag or tagdate
-			if (file_.isReadableFile()) {
-				time_t mod = file_.lastModified();
+			FileName file(owner_->absFileName());
+			if (file.isReadableFile()) {
+				time_t mod = file.lastModified();
 				string mod_date = rtrim(asctime(gmtime(&mod)), "\n");
 				LYXERR(Debug::LYXVC, "Date in Entries: `" << file_date
 					<< "'\nModification date of file: `" << mod_date << '\'');
-				if (file_.isReadOnly()) {
+				if (file.isReadOnly()) {
 					// readonly checkout is unlocked
 					vcstatus = UNLOCKED;
 				} else {
@@ -443,6 +593,15 @@ void CVS::scanMaster()
 }
 
 
+bool CVS::retrieve(FileName const & file)
+{
+	LYXERR(Debug::LYXVC, "LyXVC::CVS: retrieve.\n\t" << file);
+	// The caller ensures that file does not exist, so no need to check that.
+	return doVCCommandCall("cvs -q update " + quoteName(file.toFilesystemEncoding()),
+	                       file.onlyPath()) == 0;
+}
+
+
 string const CVS::getTarget(OperationMode opmode) const
 {
 	switch(opmode) {
@@ -588,6 +747,45 @@ void CVS::registrer(string const & msg)
 }
 
 
+bool CVS::renameEnabled()
+{
+	return true;
+}
+
+
+string CVS::rename(support::FileName const & newFile, string const & msg)
+{
+	// CVS has no real rename command, so we create a poor mans version
+	support::FileName const oldFile(owner_->absFileName());
+	string ret = copy(newFile, msg);
+	if (ret.empty())
+		return ret;
+	string cmd = "cvs -q remove -m \"" + msg + "\" " +
+		quoteName(oldFile.onlyFileName());
+	FileName path(oldFile.onlyPath());
+	return doVCCommand(cmd, path) ? string() : ret;
+}
+
+
+bool CVS::copyEnabled()
+{
+	return true;
+}
+
+
+string CVS::copy(support::FileName const & newFile, string const & msg)
+{
+	// CVS has no real copy command, so we create a poor mans version
+	support::FileName const oldFile(owner_->absFileName());
+	if (!oldFile.copyTo(newFile))
+		return string();
+	FileName path(oldFile.onlyPath());
+	string relFile(to_utf8(newFile.relPath(path.absFileName())));
+	string cmd("cvs -q add -m \"" + msg + "\" " + quoteName(relFile));
+	return doVCCommand(cmd, path) ? string() : "CVS: Proceeded";
+}
+
+
 void CVS::getDiff(OperationMode opmode, FileName const & tmpf)
 {
 	doVCCommandWithOutput("cvs diff " + getTarget(opmode),
@@ -637,22 +835,27 @@ string CVS::scanLogFile(FileName const & f, string & status)
 	ifs.close();
 	return string();
 }
-	
-	
-string CVS::checkIn(string const & msg)
+
+
+LyXVC::CommandResult CVS::checkIn(string const & msg, string & log)
 {
 	CvsStatus status = getStatus();
 	switch (status) {
 	case UpToDate:
 		if (vcstatus != NOLOCKING)
-			unedit();
-		return "CVS: Proceeded";
+			if (unedit())
+				return LyXVC::ErrorCommand;
+		log = "CVS: Proceeded";
+		return LyXVC::VCSuccess;
 	case LocallyModified:
 	case LocallyAdded: {
 		int rc = doVCCommand("cvs -q commit -m \"" + msg + "\" "
 			+ getTarget(File),
 		    FileName(owner_->filePath()));
-		return rc ? string() : "CVS: Proceeded";
+		if (rc)
+			return LyXVC::ErrorCommand;
+		log = "CVS: Proceeded";
+		return LyXVC::VCSuccess;
 	}
 	case NeedsMerge:
 	case NeedsCheckout:
@@ -667,7 +870,7 @@ string CVS::checkIn(string const & msg)
 				toString(status)));
 		break;
 	}
-	return string();
+	return LyXVC::ErrorBefore;
 }
 
 
@@ -717,7 +920,7 @@ string CVS::checkOut()
 		rc = 0;
 	}
 	
-	tmpf.erase();
+	tmpf.removeFile();
 	return rc ? string() : log.empty() ? "CVS: Proceeded" : "CVS: " + log;
 }
 
@@ -746,8 +949,8 @@ string CVS::repoUpdate()
 		docstring const file = from_utf8(owner_->filePath());
 		docstring text = bformat(_("There were detected changes "
 				"in the working directory:\n%1$s\n\n"
-				"In case of file conflict you have to resolve them "
-				"manually or revert to repository version later."), file);
+				"Possible file conflicts must be then resolved manually "
+				"or you will need to revert back to the repository version."), file);
 		int ret = frontend::Alert::prompt(_("Changes detected"),
 				text, 0, 1, _("&Continue"), _("&Abort"), _("View &Log ..."));
 		if (ret == 2 ) {
@@ -810,7 +1013,7 @@ bool CVS::isRevertWithConfirmation()
 }
 
 
-void CVS::revert()
+bool CVS::revert()
 {
 	// Reverts to the version in CVS repository and
 	// gets the updated version from the repository.
@@ -818,7 +1021,7 @@ void CVS::revert()
 	switch (status) {
 	case UpToDate:
 		if (vcstatus != NOLOCKING)
-			unedit();
+			return 0 == unedit();
 		break;
 	case NeedsMerge:
 	case NeedsCheckout:
@@ -835,7 +1038,7 @@ void CVS::revert()
 			bformat(_("The document %1$s is not in repository.\n"
 			          "You have to check in the first revision before you can revert."),
 				file)) ;
-		break;
+		return false;
 	}
 	default: {
 		docstring const file = owner_->fileName().displayName(20);
@@ -843,9 +1046,10 @@ void CVS::revert()
 			bformat(_("Cannot revert document %1$s to repository version.\n"
 			          "The status '%2$s' is unexpected."),
 				file, toString(status)));
-		break;
+		return false;
 		}
 	}
+	return true;
 }
 
 
@@ -898,15 +1102,32 @@ string CVS::revisionInfo(LyXVC::RevisionInfo const info)
 }
 
 
-bool CVS::prepareFileRevision(string const &, string &)
+bool CVS::prepareFileRevision(string const & revis, string & f)
 {
-	return false;
+	string rev = revis;
+	if (!VCS::makeRCSRevision(version_, rev))
+		return false;
+
+	FileName tmpf = FileName::tempName("lyxvcrev_" + rev + "_");
+	if (tmpf.empty()) {
+		LYXERR(Debug::LYXVC, "Could not generate logfile " << tmpf);
+		return false;
+	}
+
+	doVCCommandWithOutput("cvs update -p -r" + rev + " "
+		+ getTarget(File),
+		FileName(owner_->filePath()), tmpf);
+	if (tmpf.isFileEmpty())
+		return false;
+
+	f = tmpf.absFileName();
+	return true;
 }
 
 
 bool CVS::prepareFileRevisionEnabled()
 {
-	return false;
+	return true;
 }
 
 
@@ -916,11 +1137,9 @@ bool CVS::prepareFileRevisionEnabled()
 //
 /////////////////////////////////////////////////////////////////////
 
-SVN::SVN(FileName const & m, FileName const & f)
+SVN::SVN(FileName const & m, Buffer * b) : VCS(b)
 {
-	owner_ = 0;
 	master_ = m;
-	file_ = f;
 	locked_mode_ = 0;
 	scanMaster();
 }
@@ -928,40 +1147,44 @@ SVN::SVN(FileName const & m, FileName const & f)
 
 FileName const SVN::findFile(FileName const & file)
 {
-	// First we look for the .svn/entries in the same dir
-	// where we have file.
-	FileName const entries(onlyPath(file.absFileName()) + "/.svn/entries");
-	string const tmpf = onlyFileName(file.absFileName());
-	LYXERR(Debug::LYXVC, "LyXVC: Checking if file is under svn in `" << entries
-			     << "' for `" << tmpf << '\'');
-	if (entries.isReadableFile()) {
-		// Ok we are at least in a SVN dir. Parse the .svn/entries
-		// and see if we can find this file. We do a fast and
-		// dirty parse here.
-		ifstream ifs(entries.toFilesystemEncoding().c_str());
-		string line, oldline;
-		while (getline(ifs, line)) {
-			if (line == "dir" || line == "file")
-				LYXERR(Debug::LYXVC, "\tEntries: " << oldline);
-			if (oldline == tmpf && line == "file")
-				return entries;
-			oldline = line;
-		}
+	// First we check the existence of repository meta data.
+	if (!VCS::checkparentdirs(file, ".svn")) {
+		LYXERR(Debug::LYXVC, "Cannot find SVN meta data for " << file);
+		return FileName();
 	}
-	return FileName();
+
+	// Now we check the status of the file.
+	FileName tmpf = FileName::tempName("lyxvcout");
+	if (tmpf.empty()) {
+		LYXERR(Debug::LYXVC, "Could not generate logfile " << tmpf);
+		return FileName();
+	}
+
+	string const fname = onlyFileName(file.absFileName());
+	LYXERR(Debug::LYXVC, "LyXVC: Checking if file is under svn control for `" << fname << '\'');
+	bool found = 0 == doVCCommandCall("svn info " + quoteName(fname)
+						+ " > " + quoteName(tmpf.toFilesystemEncoding()),
+						file.onlyPath());
+	tmpf.removeFile();
+	LYXERR(Debug::LYXVC, "SVN control: " << (found ? "enabled" : "disabled"));
+	return found ? file : FileName();
 }
 
 
 void SVN::scanMaster()
 {
-	// vcstatus code is somewhat superflous, until we want
-	// to implement read-only toggle for svn.
-	vcstatus = NOLOCKING;
-	if (checkLockMode()) {
-		if (isLocked()) {
-			vcstatus = LOCKED;
-		} else {
-			vcstatus = UNLOCKED;
+	// vcstatus code other than UNVERSIONED is somewhat superflous,
+	// until we want to implement read-only toggle for svn.
+	FileName f = findFile(owner_->fileName());
+	if (f.empty()) {
+		vcstatus = UNVERSIONED;
+	} else {
+		vcstatus = NOLOCKING;
+		if (checkLockMode()) {
+			if (isLocked())
+				vcstatus = LOCKED;
+			else
+				vcstatus = UNLOCKED;
 		}
 	}
 }
@@ -972,20 +1195,20 @@ bool SVN::checkLockMode()
 	FileName tmpf = FileName::tempName("lyxvcout");
 	if (tmpf.empty()){
 		LYXERR(Debug::LYXVC, "Could not generate logfile " << tmpf);
-		return N_("Error: Could not generate logfile.");
+		return false;
 	}
 
 	LYXERR(Debug::LYXVC, "Detecting locking mode...");
-	if (doVCCommandCall("svn proplist " + quoteName(file_.onlyFileName())
+	if (doVCCommandCall("svn proplist " + quoteName(onlyFileName(owner_->absFileName()))
 		    + " > " + quoteName(tmpf.toFilesystemEncoding()),
-		    file_.onlyPath()))
+		    FileName(owner_->filePath())))
 		return false;
 
 	ifstream ifs(tmpf.toFilesystemEncoding().c_str());
 	string line;
 	bool ret = false;
 
-	while (ifs) {
+	while (ifs && !ret) {
 		getline(ifs, line);
 		LYXERR(Debug::LYXVC, line);
 		if (contains(line, "svn:needs-lock"))
@@ -1001,8 +1224,18 @@ bool SVN::checkLockMode()
 
 bool SVN::isLocked() const
 {
-	file_.refresh();
-	return !file_.isReadOnly();
+	FileName file(owner_->absFileName());
+	file.refresh();
+	return !file.isReadOnly();
+}
+
+
+bool SVN::retrieve(FileName const & file)
+{
+	LYXERR(Debug::LYXVC, "LyXVC::SVN: retrieve.\n\t" << file);
+	// The caller ensures that file does not exist, so no need to check that.
+	return doVCCommandCall("svn update -q --non-interactive " + quoteName(file.onlyFileName()),
+	                       file.onlyPath()) == 0;
 }
 
 
@@ -1013,54 +1246,156 @@ void SVN::registrer(string const & /*msg*/)
 }
 
 
-string SVN::checkIn(string const & msg)
+bool SVN::renameEnabled()
 {
-	FileName tmpf = FileName::tempName("lyxvcout");
-	if (tmpf.empty()){
-		LYXERR(Debug::LYXVC, "Could not generate logfile " << tmpf);
-		return N_("Error: Could not generate logfile.");
-	}
+	return true;
+}
 
-	doVCCommand("svn commit -m \"" + msg + "\" "
-		    + quoteName(onlyFileName(owner_->absFileName()))
-		    + " > " + quoteName(tmpf.toFilesystemEncoding()),
-		    FileName(owner_->filePath()));
 
+string SVN::rename(support::FileName const & newFile, string const & msg)
+{
+	// svn move does not require a log message, since it does not commit.
+	// In LyX we commit immediately afterwards, otherwise it could be
+	// confusing to the user to have two uncommitted files.
+	FileName path(owner_->filePath());
+	string relFile(to_utf8(newFile.relPath(path.absFileName())));
+	string cmd("svn move -q " + quoteName(onlyFileName(owner_->absFileName())) +
+	           ' ' + quoteName(relFile));
+	if (doVCCommand(cmd, path)) {
+		cmd = "svn revert -q " +
+			quoteName(onlyFileName(owner_->absFileName())) + ' ' +
+			quoteName(relFile);
+		doVCCommand(cmd, path);
+		if (newFile.exists())
+			newFile.removeFile();
+		return string();
+	}
+	vector<support::FileName> f;
+	f.push_back(owner_->fileName());
+	f.push_back(newFile);
 	string log;
-	string res = scanLogFile(tmpf, log);
-	if (!res.empty())
-		frontend::Alert::error(_("Revision control error."),
-				_("Error when committing to repository.\n"
-				"You have to manually resolve the problem.\n"
-				"LyX will reopen the document after you press OK."));
-	else
-		fileLock(false, tmpf, log);
-
-	tmpf.erase();
-	return log.empty() ? string() : "SVN: " + log;
+	if (checkIn(f, msg, log) != LyXVC::VCSuccess) {
+		cmd = "svn revert -q " +
+			quoteName(onlyFileName(owner_->absFileName())) + ' ' +
+			quoteName(relFile);
+		doVCCommand(cmd, path);
+		if (newFile.exists())
+			newFile.removeFile();
+		return string();
+	}
+	return log;
 }
 
 
-bool SVN::checkInEnabled()
+bool SVN::copyEnabled()
 {
-	if (locked_mode_)
-		return isLocked();
-	else
-		return true;
+	return true;
 }
 
 
-bool SVN::isCheckInWithConfirmation()
+string SVN::copy(support::FileName const & newFile, string const & msg)
 {
-	//FIXME diff
-	return true;
+	// svn copy does not require a log message, since it does not commit.
+	// In LyX we commit immediately afterwards, otherwise it could be
+	// confusing to the user to have an uncommitted file.
+	FileName path(owner_->filePath());
+	string relFile(to_utf8(newFile.relPath(path.absFileName())));
+	string cmd("svn copy -q " + quoteName(onlyFileName(owner_->absFileName())) +
+	           ' ' + quoteName(relFile));
+	if (doVCCommand(cmd, path))
+		return string();
+	vector<support::FileName> f(1, newFile);
+	string log;
+	if (checkIn(f, msg, log) == LyXVC::VCSuccess)
+		return log;
+	return string();
 }
 
 
-// FIXME Correctly return code should be checked instead of this.
-// This would need another solution than just plain startscript.
-// Hint from Andre': QProcess::readAllStandardError()...
-string SVN::scanLogFile(FileName const & f, string & status)
+LyXVC::CommandResult SVN::checkIn(string const & msg, string & log)
+{
+	vector<support::FileName> f(1, owner_->fileName());
+	return checkIn(f, msg, log);
+}
+
+
+LyXVC::CommandResult
+SVN::checkIn(vector<support::FileName> const & f, string const & msg, string & log)
+{
+	FileName tmpf = FileName::tempName("lyxvcout");
+	if (tmpf.empty()){
+		LYXERR(Debug::LYXVC, "Could not generate logfile " << tmpf);
+		log = N_("Error: Could not generate logfile.");
+		return LyXVC::ErrorBefore;
+	}
+
+	ostringstream os;
+	os << "svn commit -m \"" << msg << '"';
+	for (size_t i = 0; i < f.size(); ++i)
+		os << ' ' << quoteName(f[i].onlyFileName());
+	os << " > " << quoteName(tmpf.toFilesystemEncoding());
+	LyXVC::CommandResult ret =
+		doVCCommand(os.str(), FileName(owner_->filePath())) ?
+			LyXVC::ErrorCommand : LyXVC::VCSuccess;
+
+	string res = scanLogFile(tmpf, log);
+	if (!res.empty()) {
+		frontend::Alert::error(_("Revision control error."),
+				_("Error when committing to repository.\n"
+				"You have to manually resolve the problem.\n"
+				"LyX will reopen the document after you press OK."));
+		ret = LyXVC::ErrorCommand;
+	}
+	else
+		if (!fileLock(false, tmpf, log))
+			ret = LyXVC::ErrorCommand;
+
+	tmpf.removeFile();
+	if (!log.empty())
+		log.insert(0, "SVN: ");
+	if (ret == LyXVC::VCSuccess && log.empty())
+		log = "SVN: Proceeded";
+	return ret;
+}
+
+
+bool SVN::checkInEnabled()
+{
+	if (locked_mode_)
+		return isLocked();
+	else
+		return true;
+}
+
+
+bool SVN::isCheckInWithConfirmation()
+{
+	// FIXME one day common getDiff and perhaps OpMode for all backends
+
+	FileName tmpf = FileName::tempName("lyxvcout");
+	if (tmpf.empty()) {
+		LYXERR(Debug::LYXVC, "Could not generate logfile " << tmpf);
+		return true;
+	}
+
+	doVCCommandCall("svn diff " + quoteName(owner_->absFileName())
+		    + " > " + quoteName(tmpf.toFilesystemEncoding()),
+		FileName(owner_->filePath()));
+
+	docstring diff = tmpf.fileContents("UTF-8");
+	tmpf.removeFile();
+
+	if (diff.empty())
+		return false;
+
+	return true;
+}
+
+
+// FIXME Correctly return code should be checked instead of this.
+// This would need another solution than just plain startscript.
+// Hint from Andre': QProcess::readAllStandardError()...
+string SVN::scanLogFile(FileName const & f, string & status)
 {
 	ifstream ifs(f.toFilesystemEncoding().c_str());
 	string line;
@@ -1085,10 +1420,10 @@ string SVN::scanLogFile(FileName const & f, string & status)
 }
 
 
-void SVN::fileLock(bool lock, FileName const & tmpf, string &status)
+bool SVN::fileLock(bool lock, FileName const & tmpf, string &status)
 {
 	if (!locked_mode_ || (isLocked() == lock))
-		return;
+		return true;
 
 	string const arg = lock ? "lock " : "unlock ";
 	doVCCommand("svn "+ arg + quoteName(onlyFileName(owner_->absFileName()))
@@ -1104,16 +1439,20 @@ void SVN::fileLock(bool lock, FileName const & tmpf, string &status)
 	}
 	ifs.close();
 
-	if (!isLocked() && lock)
+	if (isLocked() == lock)
+		return true;
+
+	if (lock)
 		frontend::Alert::error(_("Revision control error."),
 			_("Error while acquiring write lock.\n"
 			"Another user is most probably editing\n"
 			"the current document now!\n"
 			"Also check the access to the repository."));
-	if (isLocked() && !lock)
+	else
 		frontend::Alert::error(_("Revision control error."),
 			_("Error while releasing write lock.\n"
 			"Check the access to the repository."));
+	return false;
 }
 
 
@@ -1140,7 +1479,7 @@ string SVN::checkOut()
 
 	fileLock(true, tmpf, log);
 
-	tmpf.erase();
+	tmpf.removeFile();
 	return log.empty() ? string() : "SVN: " + log;
 }
 
@@ -1183,7 +1522,7 @@ string SVN::repoUpdate()
 			hideDialogs("file", 0);
 		}
 		if (ret == 1 ) {
-			tmpf.erase();
+			tmpf.removeFile();
 			return string();
 		}
 	}
@@ -1199,7 +1538,7 @@ string SVN::repoUpdate()
 	res += "Update log:\n" + tmpf.fileContents("UTF-8");
 
 	LYXERR(Debug::LYXVC, res);
-	tmpf.erase();
+	tmpf.removeFile();
 	return to_utf8(res);
 }
 
@@ -1240,13 +1579,14 @@ string SVN::lockingToggle()
 	if (ret)
 		return string();
 
-	tmpf.erase();
-	frontend::Alert::warning(_("VCN File Locking"),
+	tmpf.removeFile();
+	frontend::Alert::warning(_("SVN File Locking"),
 		(locking ? _("Locking property unset.") : _("Locking property set.")) + "\n"
 		+ _("Do not forget to commit the locking property into the repository."),
 		true);
 
-	return string("SVN: ") +  N_("Locking property set.");
+	return string("SVN: ") + (locking ?
+		N_("Locking property unset.") : N_("Locking property set."));
 }
 
 
@@ -1256,15 +1596,17 @@ bool SVN::lockingToggleEnabled()
 }
 
 
-void SVN::revert()
+bool SVN::revert()
 {
 	// Reverts to the version in SVN repository and
 	// gets the updated version from the repository.
 	string const fil = quoteName(onlyFileName(owner_->absFileName()));
 
-	doVCCommand("svn revert -q " + fil,
-		    FileName(owner_->filePath()));
+	if (doVCCommand("svn revert -q " + fil,
+		    FileName(owner_->filePath())))
+		return false;
 	owner_->markClean();
+	return true;
 }
 
 
@@ -1293,13 +1635,13 @@ bool SVN::undoLastEnabled()
 string SVN::revisionInfo(LyXVC::RevisionInfo const info)
 {
 	if (info == LyXVC::Tree) {
-			if (rev_tree_cache_.empty())
-				if (!getTreeRevisionInfo())
-					rev_tree_cache_ = "?";
-			if (rev_tree_cache_ == "?")
-				return string();
+		if (rev_tree_cache_.empty())
+			if (!getTreeRevisionInfo())
+				rev_tree_cache_ = "?";
+		if (rev_tree_cache_ == "?")
+			return string();
 
-			return rev_tree_cache_;
+		return rev_tree_cache_;
 	}
 
 	// fill the rest of the attributes for a single file
@@ -1331,7 +1673,7 @@ bool SVN::getFileRevisionInfo()
 	FileName tmpf = FileName::tempName("lyxvcout");
 	if (tmpf.empty()) {
 		LYXERR(Debug::LYXVC, "Could not generate logfile " << tmpf);
-		return N_("Error: Could not generate logfile.");
+		return false;
 	}
 
 	doVCCommand("svn info --xml " + quoteName(onlyFileName(owner_->absFileName()))
@@ -1374,7 +1716,7 @@ bool SVN::getFileRevisionInfo()
 	}
 
 	ifs.close();
-	tmpf.erase();
+	tmpf.removeFile();
 	return !rev.empty();
 }
 
@@ -1384,7 +1726,7 @@ bool SVN::getTreeRevisionInfo()
 	FileName tmpf = FileName::tempName("lyxvcout");
 	if (tmpf.empty()) {
 		LYXERR(Debug::LYXVC, "Could not generate logfile " << tmpf);
-		return N_("Error: Could not generate logfile.");
+		return false;
 	}
 
 	doVCCommand("svnversion -n . > " + quoteName(tmpf.toFilesystemEncoding()),
@@ -1398,7 +1740,7 @@ bool SVN::getTreeRevisionInfo()
 	string line;
 	getline(ifs, line);
 	ifs.close();
-	tmpf.erase();
+	tmpf.removeFile();
 
 	rev_tree_cache_ = line;
 	return !line.empty();
@@ -1435,7 +1777,7 @@ bool SVN::prepareFileRevision(string const & revis, string & f)
 	FileName tmpf = FileName::tempName("lyxvcrev_" + revname + "_");
 	if (tmpf.empty()) {
 		LYXERR(Debug::LYXVC, "Could not generate logfile " << tmpf);
-		return N_("Error: Could not generate logfile.");
+		return false;
 	}
 
 	doVCCommand("svn cat -r " + revname + " "
@@ -1463,4 +1805,465 @@ bool SVN::toggleReadOnlyEnabled()
 }
 
 
+/////////////////////////////////////////////////////////////////////
+//
+// GIT
+//
+/////////////////////////////////////////////////////////////////////
+
+GIT::GIT(FileName const & m, Buffer * b) : VCS(b)
+{
+	master_ = m;
+	scanMaster();
+}
+
+
+FileName const GIT::findFile(FileName const & file)
+{
+	// First we check the existence of repository meta data.
+	if (!VCS::checkparentdirs(file, ".git")) {
+		LYXERR(Debug::LYXVC, "Cannot find GIT meta data for " << file);
+		return FileName();
+	}
+
+	// Now we check the status of the file.
+	FileName tmpf = FileName::tempName("lyxvcout");
+	if (tmpf.empty()) {
+		LYXERR(Debug::LYXVC, "Could not generate logfile " << tmpf);
+		return FileName();
+	}
+
+	// --porcelain selects a format that is supposed to be stable across
+	// git versions
+	string const fname = onlyFileName(file.absFileName());
+	LYXERR(Debug::LYXVC, "LyXVC: Checking if file is under git control for `"
+			<< fname << '\'');
+	bool found = 0 == doVCCommandCall("git status --porcelain " +
+				quoteName(fname) + " > " +
+				quoteName(tmpf.toFilesystemEncoding()),
+			file.onlyPath());
+	if (found)
+	{
+		// The output contains a line starting with "??" for unknown
+		// files, no line for known unmodified files and a line
+		// starting with "M" or something else for modified/deleted
+		// etc. files.
+		ifstream ifs(tmpf.toFilesystemEncoding().c_str());
+		string test;
+		if ((ifs >> test))
+			found = (test != "??");
+		// else is no error
+	}
+	tmpf.removeFile();
+	LYXERR(Debug::LYXVC, "GIT control: " << (found ? "enabled" : "disabled"));
+	return found ? file : FileName();
+}
+
+
+void GIT::scanMaster()
+{
+	// vcstatus code other than UNVERSIONED is somewhat superflous,
+	// until we want to implement read-only toggle for git.
+	FileName f = findFile(owner_->fileName());
+	if (f.empty())
+		vcstatus = UNVERSIONED;
+	else
+		vcstatus = NOLOCKING;
+}
+
+
+bool GIT::retrieve(FileName const & file)
+{
+	LYXERR(Debug::LYXVC, "LyXVC::GIT: retrieve.\n\t" << file);
+	// The caller ensures that file does not exist, so no need to check that.
+	return doVCCommandCall("git checkout -q " + quoteName(file.onlyFileName()),
+	                       file.onlyPath()) == 0;
+}
+
+
+void GIT::registrer(string const & /*msg*/)
+{
+	doVCCommand("git add " + quoteName(onlyFileName(owner_->absFileName())),
+		    FileName(owner_->filePath()));
+}
+
+
+bool GIT::renameEnabled()
+{
+	return true;
+}
+
+
+string GIT::rename(support::FileName const & newFile, string const & msg)
+{
+	// git mv does not require a log message, since it does not commit.
+	// In LyX we commit immediately afterwards, otherwise it could be
+	// confusing to the user to have two uncommitted files.
+	FileName path(owner_->filePath());
+	string relFile(to_utf8(newFile.relPath(path.absFileName())));
+	string cmd("git mv " + quoteName(onlyFileName(owner_->absFileName())) +
+	           ' ' + quoteName(relFile));
+	if (doVCCommand(cmd, path)) {
+		cmd = "git checkout -q " +
+			quoteName(onlyFileName(owner_->absFileName())) + ' ' +
+			quoteName(relFile);
+		doVCCommand(cmd, path);
+		if (newFile.exists())
+			newFile.removeFile();
+		return string();
+	}
+	vector<support::FileName> f;
+	f.push_back(owner_->fileName());
+	f.push_back(newFile);
+	string log;
+	if (checkIn(f, msg, log) != LyXVC::VCSuccess) {
+		cmd = "git checkout -q " +
+			quoteName(onlyFileName(owner_->absFileName())) + ' ' +
+			quoteName(relFile);
+		doVCCommand(cmd, path);
+		if (newFile.exists())
+			newFile.removeFile();
+		return string();
+	}
+	return log;
+}
+
+
+bool GIT::copyEnabled()
+{
+	return false;
+}
+
+
+string GIT::copy(support::FileName const & /*newFile*/, string const & /*msg*/)
+{
+	// git does not support copy with history preservation
+	return string();
+}
+
+
+LyXVC::CommandResult GIT::checkIn(string const & msg, string & log)
+{
+	vector<support::FileName> f(1, owner_->fileName());
+	return checkIn(f, msg, log);
+}
+
+
+LyXVC::CommandResult
+GIT::checkIn(vector<support::FileName> const & f, string const & msg, string & log)
+{
+	FileName tmpf = FileName::tempName("lyxvcout");
+	if (tmpf.empty()){
+		LYXERR(Debug::LYXVC, "Could not generate logfile " << tmpf);
+		log = N_("Error: Could not generate logfile.");
+		return LyXVC::ErrorBefore;
+	}
+
+	ostringstream os;
+	os << "git commit -m \"" << msg << '"';
+	for (size_t i = 0; i < f.size(); ++i)
+		os << ' ' << quoteName(f[i].onlyFileName());
+	os << " > " << quoteName(tmpf.toFilesystemEncoding());
+	LyXVC::CommandResult ret =
+		doVCCommand(os.str(), FileName(owner_->filePath())) ?
+			LyXVC::ErrorCommand : LyXVC::VCSuccess;
+
+	string res = scanLogFile(tmpf, log);
+	if (!res.empty()) {
+		frontend::Alert::error(_("Revision control error."),
+				_("Error when committing to repository.\n"
+				"You have to manually resolve the problem.\n"
+				"LyX will reopen the document after you press OK."));
+		ret = LyXVC::ErrorCommand;
+	}
+
+	tmpf.removeFile();
+	if (!log.empty())
+		log.insert(0, "GIT: ");
+	if (ret == LyXVC::VCSuccess && log.empty())
+		log = "GIT: Proceeded";
+	return ret;
+}
+
+
+bool GIT::checkInEnabled()
+{
+	return true;
+}
+
+
+bool GIT::isCheckInWithConfirmation()
+{
+	// FIXME one day common getDiff and perhaps OpMode for all backends
+
+	FileName tmpf = FileName::tempName("lyxvcout");
+	if (tmpf.empty()) {
+		LYXERR(Debug::LYXVC, "Could not generate logfile " << tmpf);
+		return true;
+	}
+
+	doVCCommandCall("git diff " + quoteName(owner_->absFileName())
+		    + " > " + quoteName(tmpf.toFilesystemEncoding()),
+		FileName(owner_->filePath()));
+
+	docstring diff = tmpf.fileContents("UTF-8");
+	tmpf.removeFile();
+
+	if (diff.empty())
+		return false;
+
+	return true;
+}
+
+
+// FIXME Correctly return code should be checked instead of this.
+// This would need another solution than just plain startscript.
+// Hint from Andre': QProcess::readAllStandardError()...
+string GIT::scanLogFile(FileName const & f, string & status)
+{
+	ifstream ifs(f.toFilesystemEncoding().c_str());
+	string line;
+
+	while (ifs) {
+		getline(ifs, line);
+		LYXERR(Debug::LYXVC, line << "\n");
+		if (!line.empty()) 
+			status += line + "; ";
+		if (prefixIs(line, "C ") || prefixIs(line, "CU ")
+					 || contains(line, "Commit failed")) {
+			ifs.close();
+			return line;
+		}
+	}
+	ifs.close();
+	return string();
+}
+
+
+string GIT::checkOut()
+{
+	return string();
+}
+
+
+bool GIT::checkOutEnabled()
+{
+	return false;
+}
+
+
+string GIT::repoUpdate()
+{
+	return string();
+}
+
+
+bool GIT::repoUpdateEnabled()
+{
+	return false;
+}
+
+
+string GIT::lockingToggle()
+{
+	return string();
+}
+
+
+bool GIT::lockingToggleEnabled()
+{
+	return false;
+}
+
+
+bool GIT::revert()
+{
+	// Reverts to the version in GIT repository and
+	// gets the updated version from the repository.
+	string const fil = quoteName(onlyFileName(owner_->absFileName()));
+
+	if (doVCCommand("git checkout -q " + fil,
+		    FileName(owner_->filePath())))
+		return false;
+	owner_->markClean();
+	return true;
+}
+
+
+bool GIT::isRevertWithConfirmation()
+{
+	//FIXME owner && diff
+	return true;
+}
+
+
+void GIT::undoLast()
+{
+	// merge the current with the previous version
+	// in a reverse patch kind of way, so that the
+	// result is to revert the last changes.
+	lyxerr << "Sorry, not implemented." << endl;
+}
+
+
+bool GIT::undoLastEnabled()
+{
+	return false;
+}
+
+
+string GIT::revisionInfo(LyXVC::RevisionInfo const info)
+{
+	if (info == LyXVC::Tree) {
+		if (rev_tree_cache_.empty())
+			if (!getTreeRevisionInfo())
+				rev_tree_cache_ = "?";
+		if (rev_tree_cache_ == "?")
+			return string();
+
+		return rev_tree_cache_;
+	}
+
+	// fill the rest of the attributes for a single file
+	if (rev_file_cache_.empty())
+		if (!getFileRevisionInfo())
+			rev_file_cache_ = "?";
+
+	switch (info) {
+		case LyXVC::File:
+			if (rev_file_cache_ == "?")
+				return string();
+			return rev_file_cache_;
+		case LyXVC::Author:
+			return rev_author_cache_;
+		case LyXVC::Date:
+			return rev_date_cache_;
+		case LyXVC::Time:
+			return rev_time_cache_;
+		default: ;
+
+	}
+
+	return string();
+}
+
+
+bool GIT::getFileRevisionInfo()
+{
+	FileName tmpf = FileName::tempName("lyxvcout");
+	if (tmpf.empty()) {
+		LYXERR(Debug::LYXVC, "Could not generate logfile " << tmpf);
+		return false;
+	}
+
+	doVCCommand("git log -n 1 --pretty=format:%H%n%an%n%ai " + quoteName(onlyFileName(owner_->absFileName()))
+		    + " > " + quoteName(tmpf.toFilesystemEncoding()),
+		    FileName(owner_->filePath()));
+
+	if (tmpf.empty())
+		return false;
+
+	ifstream ifs(tmpf.toFilesystemEncoding().c_str());
+
+	if (ifs)
+		getline(ifs, rev_file_cache_);
+	if (ifs)
+		getline(ifs, rev_author_cache_);
+	if (ifs) {
+		string line;
+		getline(ifs, line);
+		rev_time_cache_ = split(line, rev_date_cache_, ' ');
+	}
+
+	ifs.close();
+	tmpf.removeFile();
+	return !rev_file_cache_.empty();
+}
+
+
+bool GIT::getTreeRevisionInfo()
+{
+	FileName tmpf = FileName::tempName("lyxvcout");
+	if (tmpf.empty()) {
+		LYXERR(Debug::LYXVC, "Could not generate logfile " << tmpf);
+		return false;
+	}
+
+	doVCCommand("git describe --abbrev --dirty --long > " + quoteName(tmpf.toFilesystemEncoding()),
+		    FileName(owner_->filePath()));
+
+	if (tmpf.empty())
+		return false;
+
+	// only first line in case something bad happens.
+	ifstream ifs(tmpf.toFilesystemEncoding().c_str());
+	getline(ifs, rev_tree_cache_);
+	ifs.close();
+	tmpf.removeFile();
+
+	return !rev_tree_cache_.empty();
+}
+
+
+void GIT::getLog(FileName const & tmpf)
+{
+	doVCCommand("git log " + quoteName(onlyFileName(owner_->absFileName()))
+		    + " > " + quoteName(tmpf.toFilesystemEncoding()),
+		    FileName(owner_->filePath()));
+}
+
+
+//at this moment we don't accept revision SHA, but just number of revision steps back
+//GUI and infrastucture needs to be changed first
+bool GIT::prepareFileRevision(string const & revis, string & f)
+{
+	// anything positive means we got hash, not "0" or minus revision
+	int rev = 1;
+
+	// hash is rarely number and should be long
+	if (isStrInt(revis) && revis.length()<20)
+		rev = convert<int>(revis);
+
+	// revision and filename
+	string pointer;
+
+	// go back for "minus" revisions
+	if (rev <= 0)
+		pointer = "HEAD~" + convert<string>(-rev);
+	// normal hash
+	else
+		pointer = revis;
+
+	pointer += ":";
+
+	FileName tmpf = FileName::tempName("lyxvcrev_" + revis + "_");
+	if (tmpf.empty()) {
+		LYXERR(Debug::LYXVC, "Could not generate logfile " << tmpf);
+		return false;
+	}
+
+	doVCCommand("git show " + pointer + "./"
+	              + quoteName(onlyFileName(owner_->absFileName()))
+		      + " > " + quoteName(tmpf.toFilesystemEncoding()),
+		FileName(owner_->filePath()));
+	if (tmpf.isFileEmpty())
+		return false;
+
+	f = tmpf.absFileName();
+	return true;
+}
+
+
+bool GIT::prepareFileRevisionEnabled()
+{
+	return true;
+}
+
+
+bool GIT::toggleReadOnlyEnabled()
+{
+	return false;
+}
+
+
 } // namespace lyx