/*
* ====================================================================
* Copyright (c) 2004-2012 TMate Software Ltd. All rights reserved.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
* are also available at http://svnkit.com/license.html
* If newer versions of this license are posted there, you may use a
* newer version instead, at your option.
* ====================================================================
*/
package org.tmatesoft.svn.core.internal.wc;
import java.io.File;
import java.io.UnsupportedEncodingException;
import java.util.Iterator;
import java.util.Map;
import org.tmatesoft.svn.core.SVNErrorCode;
import org.tmatesoft.svn.core.SVNErrorMessage;
import org.tmatesoft.svn.core.SVNException;
import org.tmatesoft.svn.core.SVNNodeKind;
import org.tmatesoft.svn.core.SVNURL;
import org.tmatesoft.svn.core.internal.util.SVNHashMap;
import org.tmatesoft.svn.core.internal.util.SVNSkel;
import org.tmatesoft.svn.core.io.SVNRepository;
import org.tmatesoft.svn.core.wc.SVNConflictAction;
import org.tmatesoft.svn.core.wc.SVNConflictReason;
import org.tmatesoft.svn.core.wc.SVNOperation;
import org.tmatesoft.svn.core.wc.SVNTreeConflictDescription;
import org.tmatesoft.svn.util.SVNLogType;
/**
* @author TMate Software Ltd.
* @version 1.3
*/
public class SVNTreeConflictUtil {
public static Map readTreeConflicts(File dirPath, String conflictData) throws SVNException {
if (conflictData == null) {
return new SVNHashMap();
}
byte[] data;
try {
data = conflictData.getBytes("UTF-8");
} catch (UnsupportedEncodingException e) {
data = conflictData.getBytes();
}
return readTreeConflicts(dirPath, data);
}
public static Map readTreeConflicts(File dirPath, byte[] conflictData) throws SVNException {
Map conflicts = new SVNHashMap();
if (conflictData == null) {
return conflicts;
}
SVNSkel skel = SVNSkel.parse(conflictData);
if (skel == null || skel.isAtom()) {
SVNErrorMessage error = SVNErrorMessage.create(SVNErrorCode.WC_CORRUPT, "Error parsing tree conflict skel");
SVNErrorManager.error(error, SVNLogType.WC);
}
for (Iterator iterator = skel.getList().iterator(); iterator.hasNext();) {
SVNSkel conflictSkel = (SVNSkel) iterator.next();
SVNTreeConflictDescription conflict = readSingleTreeConflict(conflictSkel, dirPath);
if (conflict != null) {
conflicts.put(conflict.getPath(), conflict);
}
}
return conflicts;
}
public static SVNTreeConflictDescription readSingleTreeConflict(SVNSkel skel, File dirPath) throws SVNException {
if (!isValidConflict(skel)) {
SVNErrorMessage error = SVNErrorMessage.create(SVNErrorCode.WC_CORRUPT, "Invalid conflict info in tree conflict description");
SVNErrorManager.error(error, SVNLogType.WC);
}
if (skel.getChild(1).getData().length == 0) {
SVNErrorMessage error = SVNErrorMessage.create(SVNErrorCode.WC_CORRUPT, "Empty \'victim\' field in tree conflict description");
SVNErrorManager.error(error, SVNLogType.WC);
}
String victimBasename = skel.getChild(1).getValue();
SVNNodeKind kind = getNodeKind(skel.getChild(2).getValue());
if (kind != SVNNodeKind.FILE && kind != SVNNodeKind.DIR) {
SVNErrorMessage error = SVNErrorMessage.create(SVNErrorCode.WC_CORRUPT, "Invalid \'node_kind\' field in tree conflict description");
SVNErrorManager.error(error, SVNLogType.WC);
}
SVNOperation operation = getOperation(skel.getChild(3).getValue());
SVNConflictAction action = getAction(skel.getChild(4).getValue());
SVNConflictReason reason = getConflictReason(skel.getChild(5).getValue());
SVNConflictVersion srcLeftVersion = readConflictVersion(skel.getChild(6));
SVNConflictVersion srcRightVersion = readConflictVersion(skel.getChild(7));
return new SVNTreeConflictDescription(new File(dirPath, victimBasename), kind, action, reason, operation, srcLeftVersion, srcRightVersion);
}
private static SVNConflictVersion readConflictVersion(SVNSkel skel) throws SVNException {
if (!isValidVersionInfo(skel)) {
SVNErrorMessage error = SVNErrorMessage.create(SVNErrorCode.WC_CORRUPT, "Invalid version info in tree conflict description");
SVNErrorManager.error(error, SVNLogType.WC);
}
String repoURLString = skel.getChild(1).getValue();
SVNURL repoURL = repoURLString.length() == 0 ? null : SVNURL.parseURIEncoded(repoURLString);
if (repoURL == null) {
return null;
}
long pegRevision = Long.parseLong(skel.getChild(2).getValue());
String path = skel.getChild(3).getValue();
path = path.length() == 0 ? null : path;
SVNNodeKind kind = getNodeKind(skel.getChild(4).getValue());
return new SVNConflictVersion(repoURL, path, pegRevision, kind);
}
private static boolean isValidVersionInfo(SVNSkel skel) throws SVNException {
if (skel.getListSize() != 5 || !skel.getChild(0).contentEquals("version")) {
return false;
}
return skel.containsAtomsOnly();
}
private static boolean isValidConflict(SVNSkel skel) throws SVNException {
if (skel.getListSize() != 8 || !skel.getChild(0).contentEquals("conflict")) {
return false;
}
for (int i = 1; i < 6; i++) {
SVNSkel element = skel.getChild(i);
if (!element.isAtom()) {
return false;
}
}
return isValidVersionInfo(skel.getChild(6)) && isValidVersionInfo(skel.getChild(7));
}
public static String getTreeConflictData(Map conflicts) throws SVNException {
if (conflicts == null) {
return null;
}
byte[] rawData = getTreeConflictRawData(conflicts);
String conflictData;
try {
conflictData = new String(rawData, "UTF-8");
} catch (UnsupportedEncodingException e) {
conflictData = new String(rawData);
}
return conflictData;
}
public static byte[] getTreeConflictRawData(Map conflicts) throws SVNException {
if (conflicts == null) {
return null;
}
SVNConflictVersion nullVersion = new SVNConflictVersion(null, null, SVNRepository.INVALID_REVISION, SVNNodeKind.UNKNOWN);
SVNSkel skel = SVNSkel.createEmptyList();
for (Iterator iterator = conflicts.values().iterator(); iterator.hasNext();) {
SVNTreeConflictDescription conflict = (SVNTreeConflictDescription) iterator.next();
SVNSkel conflictSkel = getConflictSkel(nullVersion, conflict);
if (!isValidConflict(conflictSkel)) {
SVNErrorMessage error = SVNErrorMessage.create(SVNErrorCode.WC_CORRUPT,
"Failed to create valid conflict description skel: ''{0}''", skel.toString());
SVNErrorManager.error(error, SVNLogType.WC);
}
skel.prepend(conflictSkel);
}
return skel.unparse();
}
public static String getSingleTreeConflictData(SVNTreeConflictDescription conflict) throws SVNException {
if (conflict == null) {
return null;
}
byte[] rawData = getSingleTreeConflictRawData(conflict);
String conflictData;
try {
conflictData = new String(rawData, "UTF-8");
} catch (UnsupportedEncodingException e) {
conflictData = new String(rawData);
}
return conflictData;
}
public static byte[] getSingleTreeConflictRawData(SVNTreeConflictDescription conflict) throws SVNException {
SVNConflictVersion nullVersion = new SVNConflictVersion(null, null, SVNRepository.INVALID_REVISION, SVNNodeKind.UNKNOWN);
SVNSkel conflictSkel = getConflictSkel(nullVersion, conflict);
if (!isValidConflict(conflictSkel)) {
SVNErrorMessage error = SVNErrorMessage.create(SVNErrorCode.WC_CORRUPT,
"Failed to create valid conflict description skel: ''{0}''", conflictSkel.toString());
SVNErrorManager.error(error, SVNLogType.WC);
}
return conflictSkel.unparse();
}
public static SVNSkel getConflictSkel(SVNConflictVersion nullVersion, SVNTreeConflictDescription conflict) throws SVNException {
SVNSkel conflictSkel = SVNSkel.createEmptyList();
SVNConflictVersion sourceRightVersion = conflict.getSourceRightVersion();
sourceRightVersion = sourceRightVersion == null ? nullVersion : sourceRightVersion;
prependVersionInfo(conflictSkel, sourceRightVersion);
SVNConflictVersion sourceLeftVersion = conflict.getSourceLeftVersion();
sourceLeftVersion = sourceLeftVersion == null ? nullVersion : sourceLeftVersion;
prependVersionInfo(conflictSkel, sourceLeftVersion);
conflictSkel.prepend(SVNSkel.createAtom(conflict.getConflictReason().toString()));
conflictSkel.prepend(SVNSkel.createAtom(conflict.getConflictAction().toString()));
conflictSkel.prepend(SVNSkel.createAtom(conflict.getOperation().toString()));
if (conflict.getNodeKind() != SVNNodeKind.DIR && conflict.getNodeKind() != SVNNodeKind.FILE) {
SVNErrorMessage error = SVNErrorMessage.create(SVNErrorCode.WC_CORRUPT,
"Invalid \'node_kind\' field in tree conflict description");
SVNErrorManager.error(error, SVNLogType.WC);
}
conflictSkel.prepend(SVNSkel.createAtom(getNodeKindString(conflict.getNodeKind())));
String path = conflict.getPath().getName();
if (path.length() == 0) {
SVNErrorMessage error = SVNErrorMessage.create(SVNErrorCode.WC_CORRUPT,
"Empty path basename in tree conflict description");
SVNErrorManager.error(error, SVNLogType.WC);
}
conflictSkel.prepend(SVNSkel.createAtom(path));
conflictSkel.prepend(SVNSkel.createAtom("conflict"));
return conflictSkel;
}
public static String getHumanReadableConflictDescription(SVNTreeConflictDescription treeConflict) {
final String reasonStr = getReasonString(treeConflict);
final String actionStr = getActionString(treeConflict);
final String operationStr = treeConflict.getOperation().getName();
final String kindStr = treeConflict.getNodeKind().toString();
final String description = String.format("local %s %s, incoming %s %s upon %s", kindStr, reasonStr, kindStr, actionStr, operationStr);
return description;
}
public static String getHumanReadableConflictVersion(SVNConflictVersion version) {
if (version == null) {
return "(none)";
}
String url = version.getRepositoryRoot() != null ? version.getRepositoryRoot().toString() : null;
if (url != null && version.getPath() != null) {
url = url + "/" + version.getPath();
} else if (url != null) {
url = url + "/...";
} else if (version.getPath() != null) {
url = version.getPath();
} else {
url = "...";
}
return "(" + getNodeKindString(version.getKind()) + ") " + url + "@" + version.getPegRevision();
}
private static String getReasonString(SVNTreeConflictDescription treeConflict) {
final SVNConflictReason reason = treeConflict.getConflictReason();
if (reason == SVNConflictReason.EDITED) {
return "edit";
} else if (reason == SVNConflictReason.OBSTRUCTED) {
return "obstruction";
} else if (reason == SVNConflictReason.DELETED) {
return "delete";
} else if (reason == SVNConflictReason.ADDED) {
return "add";
} else if (reason == SVNConflictReason.MISSING) {
return "missing";
} else if (reason == SVNConflictReason.UNVERSIONED) {
return "unversioned";
}
return null;
}
private static String getActionString(SVNTreeConflictDescription treeConflict) {
SVNConflictAction action = treeConflict.getConflictAction();
if (action == SVNConflictAction.ADD) {
return "add";
} else if (action == SVNConflictAction.EDIT) {
return "edit";
} else if (action == SVNConflictAction.DELETE) {
return "delete";
} else if (action == SVNConflictAction.REPLACE) {
return "replace";
}
return null;
}
private static SVNSkel prependVersionInfo(SVNSkel parent, SVNConflictVersion versionInfo) throws SVNException {
parent = parent == null ? SVNSkel.createEmptyList() : parent;
SVNSkel skel = SVNSkel.createEmptyList();
skel.prepend(SVNSkel.createAtom(getNodeKindString(versionInfo.getKind())));
String path = versionInfo.getPath() == null ? "" : versionInfo.getPath();
skel.prepend(SVNSkel.createAtom(path));
skel.prepend(SVNSkel.createAtom(String.valueOf(versionInfo.getPegRevision())));
String repoURLString = versionInfo.getRepositoryRoot() == null ? "" : versionInfo.getRepositoryRoot().toString();
skel.prepend(SVNSkel.createAtom(repoURLString));
skel.prepend(SVNSkel.createAtom("version"));
if (!isValidVersionInfo(skel)) {
SVNErrorMessage error = SVNErrorMessage.create(SVNErrorCode.WC_CORRUPT, "Failed to create valid conflict version skel: ''{0}''", skel.toString());
SVNErrorManager.error(error, SVNLogType.WC);
}
parent.prepend(skel);
return parent;
}
private static SVNNodeKind getNodeKind(String name) throws SVNException {
if ("".equals(name)) {
return SVNNodeKind.UNKNOWN;
}
SVNNodeKind kind = SVNNodeKind.parseKind(name);
if (kind == SVNNodeKind.UNKNOWN) {
mappingError("node kind");
}
return kind;
}
private static String getNodeKindString(SVNNodeKind kind) {
if (kind ==SVNNodeKind.UNKNOWN) {
return "";
}
return kind.toString();
}
private static SVNOperation getOperation(String name) throws SVNException {
SVNOperation operation = SVNOperation.fromString(name);
if (operation == null) {
mappingError("operation");
}
return operation;
}
private static SVNConflictAction getAction(String name) throws SVNException {
SVNConflictAction action = SVNConflictAction.fromString(name);
if (action == null) {
mappingError("conflict action");
}
return action;
}
private static SVNConflictReason getConflictReason(String name) throws SVNException {
SVNConflictReason reason;
/*
if (SVNConflictReason.UNVERSIONED.getName().equals(name)) {
reason = null;
} else {
reason = SVNConflictReason.fromString(name);
}
*/
reason = SVNConflictReason.fromString(name);
if (reason == null) {
mappingError("conflict reason");
}
return reason;
}
private static void mappingError(String type) throws SVNException {
SVNErrorMessage error = SVNErrorMessage.create(SVNErrorCode.WC_CORRUPT, "Unknown {0} value in tree conflict description", type);
SVNErrorManager.error(error, SVNLogType.WC);
}
}