@Override
public List<Commit> getHistory(int page, int limit, String until)
throws AmbiguousObjectException, IOException, NoHeadException, GitAPIException, SVNException {
// Get the repository
SVNURL svnURL = SVNURL.fromFile(new File(repoPrefix + ownerName + "/" + projectName));
org.tmatesoft.svn.core.io.SVNRepository repository = SVNRepositoryFactory.create(svnURL);
// path to get log
String[] paths = {"/"};
// Determine revisions
long startRevision = repository.getLatestRevision() - page * limit;
long endRevision = startRevision - limit;
if (endRevision < 1) {
endRevision = 1;
}
// No log to return.
if (startRevision < endRevision) {
return new ArrayList<>();
}
// Get the logs
List<Commit> result = new ArrayList<>();
for (Object entry : repository.log(paths, null, startRevision, endRevision, false, false)) {
result.add(new SvnCommit((SVNLogEntry) entry));
}
return result;
}
@Override
public <S> List<S> filterUniqueRoots(
final List<S> in, final Convertor<S, VirtualFile> convertor) {
if (in.size() <= 1) return in;
final List<MyPair<S>> infos = new ArrayList<MyPair<S>>(in.size());
final SvnFileUrlMappingImpl mapping = (SvnFileUrlMappingImpl) getSvnFileUrlMapping();
final List<S> notMatched = new LinkedList<S>();
for (S s : in) {
final VirtualFile vf = convertor.convert(s);
if (vf == null) continue;
final File ioFile = new File(vf.getPath());
SVNURL url = mapping.getUrlForFile(ioFile);
if (url == null) {
url = SvnUtil.getUrl(this, ioFile);
if (url == null) {
notMatched.add(s);
continue;
}
}
infos.add(new MyPair<S>(vf, url.toString(), s));
}
final List<MyPair<S>> filtered = new ArrayList<MyPair<S>>(infos.size());
ForNestedRootChecker.filterOutSuperfluousChildren(this, infos, filtered);
final List<S> converted =
ObjectsConvertor.convert(
filtered,
new Convertor<MyPair<S>, S>() {
@Override
public S convert(final MyPair<S> o) {
return o.getSrc();
}
});
if (!notMatched.isEmpty()) {
// potential bug is here: order is not kept. but seems it only occurs for cases where result
// is sorted after filtering so ok
converted.addAll(notMatched);
}
return converted;
}
@Override
public Commit getCommit(String revNumber) throws IOException, SVNException {
long rev = Integer.parseInt(revNumber);
String[] paths = {"/"};
SVNURL svnURL = SVNURL.fromFile(new File(getRepoPrefix() + ownerName + "/" + projectName));
org.tmatesoft.svn.core.io.SVNRepository repository = SVNRepositoryFactory.create(svnURL);
for (Object entry : repository.log(paths, null, rev, rev, false, false)) {
return new SvnCommit((SVNLogEntry) entry);
}
return null;
}
private void tryByRoot(
SvnChangeList[] result, SVNLogClient logger, SVNRevision revisionBefore, SVNURL repositoryUrl)
throws VcsException {
final boolean authorized =
SvnAuthenticationNotifier.passiveValidation(myProject, repositoryUrl);
if (!authorized) return;
tryExactHit(
new SvnRepositoryLocation(repositoryUrl.toString()),
result,
logger,
revisionBefore,
repositoryUrl,
repositoryUrl);
}
@Override
public String getPatch(String commitId) throws SVNException {
// Prepare required arguments.
SVNURL svnURL = SVNURL.fromFile(new File(getRepoPrefix() + ownerName + "/" + projectName));
long rev = Integer.parseInt(commitId);
// Get diffClient.
SVNClientManager clientManager = SVNClientManager.newInstance();
SVNDiffClient diffClient = clientManager.getDiffClient();
// Using diffClient, write the changes by commitId into
// byteArrayOutputStream, as unified format.
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
diffClient.doDiff(
svnURL,
null,
SVNRevision.create(rev - 1),
SVNRevision.create(rev),
SVNDepth.INFINITY,
true,
byteArrayOutputStream);
return byteArrayOutputStream.toString();
}
private org.tmatesoft.svn.core.io.SVNRepository getSVNRepository() throws SVNException {
SVNURL svnURL = SVNURL.fromFile(new File(getRepoPrefix() + ownerName + "/" + projectName));
return SVNRepositoryFactory.create(svnURL);
}
@Override
public Pair<SvnChangeList, FilePath> getOneList(final VirtualFile file, VcsRevisionNumber number)
throws VcsException {
final RootUrlInfo rootUrlInfo =
myVcs.getSvnFileUrlMapping().getWcRootForFilePath(new File(file.getPath()));
if (rootUrlInfo == null) return null;
final VirtualFile root = rootUrlInfo.getVirtualFile();
if (root == null) return null;
final SvnRepositoryLocation svnRootLocation =
(SvnRepositoryLocation) getLocationFor(new FilePathImpl(root));
if (svnRootLocation == null) return null;
final String url = svnRootLocation.getURL();
final long revision;
try {
revision = Long.parseLong(number.asString());
} catch (NumberFormatException e) {
throw new VcsException(e);
}
final SvnChangeList[] result = new SvnChangeList[1];
final SVNLogClient logger;
final SVNRevision revisionBefore;
final SVNURL repositoryUrl;
final SVNURL svnurl;
final SVNInfo targetInfo;
try {
logger = myVcs.createLogClient();
revisionBefore = SVNRevision.create(revision);
svnurl = SVNURL.parseURIEncoded(url);
final SVNWCClient client = myVcs.createWCClient();
final SVNInfo info = client.doInfo(svnurl, SVNRevision.UNDEFINED, SVNRevision.HEAD);
targetInfo = client.doInfo(new File(file.getPath()), SVNRevision.UNDEFINED);
if (info == null) {
throw new VcsException("Can not get repository URL");
}
repositoryUrl = info.getRepositoryRootURL();
} catch (SVNException e) {
LOG.info(e);
throw new VcsException(e);
}
tryExactHit(svnRootLocation, result, logger, revisionBefore, repositoryUrl, svnurl);
if (result[0] == null) {
tryByRoot(result, logger, revisionBefore, repositoryUrl);
if (result[0] == null) {
FilePath path =
tryStepByStep(svnRootLocation, result, logger, revisionBefore, targetInfo, svnurl);
path = path == null ? new FilePathImpl(file) : path;
// and pass & take rename context there
return new Pair<SvnChangeList, FilePath>(result[0], path);
}
}
if (result[0].getChanges().size() == 1) {
final Collection<Change> changes = result[0].getChanges();
final Change change = changes.iterator().next();
final ContentRevision afterRevision = change.getAfterRevision();
if (afterRevision != null) {
return new Pair<SvnChangeList, FilePath>(result[0], afterRevision.getFile());
} else {
return new Pair<SvnChangeList, FilePath>(result[0], new FilePathImpl(file));
}
}
String relativePath =
SVNPathUtil.getRelativePath(
targetInfo.getRepositoryRootURL().toString(), targetInfo.getURL().toString());
relativePath = relativePath.startsWith("/") ? relativePath : "/" + relativePath;
final Change targetChange = result[0].getByPath(relativePath);
if (targetChange == null) {
FilePath path =
tryStepByStep(svnRootLocation, result, logger, revisionBefore, targetInfo, svnurl);
path = path == null ? new FilePathImpl(file) : path;
// and pass & take rename context there
return new Pair<SvnChangeList, FilePath>(result[0], path);
}
return new Pair<SvnChangeList, FilePath>(result[0], new FilePathImpl(file));
}
private void getCommittedChangesImpl(
ChangeBrowserSettings settings,
final String url,
final String[] filterUrls,
final int maxCount,
final Consumer<SVNLogEntry> resultConsumer,
final boolean includeMergedRevisions,
final boolean filterOutByDate)
throws VcsException {
final ProgressIndicator progress = ProgressManager.getInstance().getProgressIndicator();
if (progress != null) {
progress.setText(SvnBundle.message("progress.text.changes.collecting.changes"));
progress.setText2(SvnBundle.message("progress.text2.changes.establishing.connection", url));
}
try {
SVNLogClient logger = myVcs.createLogClient();
final String author = settings.getUserFilter();
final Date dateFrom = settings.getDateAfterFilter();
final Long changeFrom = settings.getChangeAfterFilter();
final Date dateTo = settings.getDateBeforeFilter();
final Long changeTo = settings.getChangeBeforeFilter();
final SVNRevision revisionBefore;
if (dateTo != null) {
revisionBefore = SVNRevision.create(dateTo);
} else if (changeTo != null) {
revisionBefore = SVNRevision.create(changeTo.longValue());
} else {
SVNRepository repository = null;
final long revision;
try {
repository = myVcs.createRepository(url);
revision = repository.getLatestRevision();
} finally {
if (repository != null) {
repository.closeSession();
}
}
revisionBefore = SVNRevision.create(revision);
}
final SVNRevision revisionAfter;
if (dateFrom != null) {
revisionAfter = SVNRevision.create(dateFrom);
} else if (changeFrom != null) {
revisionAfter = SVNRevision.create(changeFrom.longValue());
} else {
revisionAfter = SVNRevision.create(1);
}
logger.doLog(
SVNURL.parseURIEncoded(url),
filterUrls,
revisionBefore,
revisionBefore,
revisionAfter,
settings.STOP_ON_COPY,
true,
includeMergedRevisions,
maxCount,
null,
new ISVNLogEntryHandler() {
public void handleLogEntry(SVNLogEntry logEntry) {
if (myProject.isDisposed()) throw new ProcessCanceledException();
if (progress != null) {
progress.setText2(
SvnBundle.message(
"progress.text2.processing.revision", logEntry.getRevision()));
progress.checkCanceled();
}
if (filterOutByDate && logEntry.getDate() == null) {
// do not add lists without info - this situation is possible for lists where there
// are paths that user has no rights to observe
return;
}
if (author == null || author.equalsIgnoreCase(logEntry.getAuthor())) {
resultConsumer.consume(logEntry);
}
}
});
} catch (SVNException e) {
throw new VcsException(e);
}
}
public SVNRepository createRepository(String url) throws SVNException {
SVNRepository repos = SVNRepositoryFactory.create(SVNURL.parseURIEncoded(url));
repos.setAuthenticationManager(myConfiguration.getAuthenticationManager(this));
repos.setTunnelProvider(myConfiguration.getOptions(myProject));
return repos;
}
private void doList(
SVNRepository repos,
long rev,
final ISVNDirEntryHandler handler,
boolean fetchLocks,
SVNDepth depth,
int entryFields,
SVNURL externalParentUrl,
String externalTarget)
throws SVNException {
boolean includeExternals = !getOperation().isIgnoreExternals();
Map<SVNURL, SVNPropertyValue> externals =
includeExternals ? new HashMap<SVNURL, SVNPropertyValue>() : null;
SVNURL url = repos.getLocation();
SVNURL reposRoot = repos.getRepositoryRoot(false);
SVNDirEntry entry = null;
SVNException error = null;
try {
entry = repos.info("", rev);
} catch (SVNException svne) {
if (svne.getErrorMessage().getErrorCode() == SVNErrorCode.RA_NOT_IMPLEMENTED) {
error = svne;
} else {
throw svne;
}
}
if (error != null) {
SVNNodeKind kind = repos.checkPath("", rev);
if (kind != SVNNodeKind.NONE) {
if (!url.equals(reposRoot)) {
String name = SVNPathUtil.tail(repos.getLocation().getPath());
repos.setLocation(repos.getLocation().removePathTail(), false);
Collection<SVNDirEntry> dirEntries =
repos.getDir("", rev, null, entryFields, (Collection) null);
repos.setLocation(url, false);
for (Iterator<SVNDirEntry> ents = dirEntries.iterator(); ents.hasNext(); ) {
SVNDirEntry dirEntry = (SVNDirEntry) ents.next();
if (name.equals(dirEntry.getName())) {
entry = dirEntry;
break;
}
}
if (entry != null) {
entry.setRelativePath(kind == SVNNodeKind.FILE ? name : "");
}
} else {
SVNProperties props = new SVNProperties();
repos.getDir("", rev, props, entryFields, (Collection<SVNDirEntry>) null);
SVNProperties revProps = repos.getRevisionProperties(rev, null);
String author = revProps.getStringValue(SVNRevisionProperty.AUTHOR);
String dateStr = revProps.getStringValue(SVNRevisionProperty.DATE);
Date datestamp = null;
if (dateStr != null) {
datestamp = SVNDate.parseDateString(dateStr);
}
entry =
new SVNDirEntry(
url, reposRoot, "", kind, 0, !props.isEmpty(), rev, datestamp, author);
entry.setRelativePath("");
}
}
} else if (entry != null) {
if (entry.getKind() == SVNNodeKind.DIR) {
entry.setName("");
}
entry.setRelativePath(entry.getKind() == SVNNodeKind.DIR ? "" : entry.getName());
}
if (entry == null) {
SVNErrorMessage err =
SVNErrorMessage.create(
SVNErrorCode.FS_NOT_FOUND, "URL ''{0}'' non-existent in that revision", url);
SVNErrorManager.error(err, SVNLogType.WC);
}
final Map locksMap = new SVNHashMap();
if (fetchLocks) {
SVNLock[] locks = new SVNLock[0];
try {
locks = repos.getLocks("");
} catch (SVNException e) {
if (!(e.getErrorMessage() != null
&& e.getErrorMessage().getErrorCode() == SVNErrorCode.RA_NOT_IMPLEMENTED)) {
throw e;
}
}
if (locks != null && locks.length > 0) {
SVNURL root = repos.getRepositoryRoot(true);
for (int i = 0; i < locks.length; i++) {
String repositoryPath = locks[i].getPath();
locksMap.put(root.appendPath(repositoryPath, false), locks[i]);
}
}
}
ISVNDirEntryHandler nestedHandler =
new ISVNDirEntryHandler() {
public void handleDirEntry(SVNDirEntry dirEntry) throws SVNException {
dirEntry.setLock((SVNLock) locksMap.get(dirEntry.getURL()));
handler.handleDirEntry(dirEntry);
}
};
entry.setExternalParentUrl(externalParentUrl);
entry.setExternalTarget(externalTarget);
nestedHandler.handleDirEntry(entry);
if (entry.getKind() == SVNNodeKind.DIR
&& (depth == SVNDepth.FILES
|| depth == SVNDepth.IMMEDIATES
|| depth == SVNDepth.INFINITY)) {
list(
repos,
"",
rev,
depth,
entryFields,
externals,
externalParentUrl,
externalTarget,
nestedHandler);
}
if (includeExternals && externals != null && externals.size() > 0) {
listExternals(repos, externals, depth, entryFields, fetchLocks, handler);
}
}
private static void list(
SVNRepository repository,
String path,
long rev,
SVNDepth depth,
int entryFields,
Map<SVNURL, SVNPropertyValue> externals,
SVNURL externalParentUrl,
String externalTarget,
ISVNDirEntryHandler handler)
throws SVNException {
if (depth == SVNDepth.EMPTY) {
return;
}
Collection entries = new TreeSet();
SVNProperties properties;
try {
properties = externals == null ? null : new SVNProperties();
entries = repository.getDir(path, rev, properties, entryFields, entries);
} catch (SVNAuthenticationException e) {
return;
} catch (SVNException e) {
if (e.getErrorMessage().getErrorCode() == SVNErrorCode.RA_NOT_AUTHORIZED) {
return;
}
throw e;
}
SVNPropertyValue svnExternalsVaule =
properties == null ? null : properties.getSVNPropertyValue(SVNProperty.EXTERNALS);
if (svnExternalsVaule != null) {
SVNURL location = repository.getLocation();
externals.put(location.appendPath(path, false), svnExternalsVaule);
}
for (Iterator iterator = entries.iterator(); iterator.hasNext(); ) {
SVNDirEntry entry = (SVNDirEntry) iterator.next();
String childPath = SVNPathUtil.append(path, entry.getName());
entry.setRelativePath(childPath);
if (entry.getKind() == SVNNodeKind.FILE
|| depth == SVNDepth.IMMEDIATES
|| depth == SVNDepth.INFINITY) {
entry.setExternalParentUrl(externalParentUrl);
entry.setExternalTarget(externalTarget);
handler.handleDirEntry(entry);
}
if (entry.getKind() == SVNNodeKind.DIR
&& entry.getDate() != null
&& depth == SVNDepth.INFINITY) {
list(
repository,
childPath,
rev,
depth,
entryFields,
externals,
externalParentUrl,
externalTarget,
handler);
}
}
}