private Couple<String> keyForChange(final Change change) {
final FilePath beforePath = ChangesUtil.getBeforePath(change);
final String beforeKey = beforePath == null ? null : beforePath.getIOFile().getAbsolutePath();
final FilePath afterPath = ChangesUtil.getAfterPath(change);
final String afterKey = afterPath == null ? null : afterPath.getIOFile().getAbsolutePath();
return Couple.of(beforeKey, afterKey);
}
private void collectLogEntries(
final ProgressIndicator indicator,
FilePath file,
VcsException[] exception,
final Consumer<VcsFileRevision> result,
final Ref<Boolean> supports15Ref)
throws SVNException, VcsException {
SVNWCClient wcClient = myVcs.createWCClient();
SVNInfo info =
wcClient.doInfo(new File(file.getIOFile().getAbsolutePath()), SVNRevision.UNDEFINED);
wcClient.setEventHandler(
new ISVNEventHandler() {
public void handleEvent(SVNEvent event, double progress) throws SVNException {}
public void checkCancelled() throws SVNCancelException {
indicator.checkCanceled();
}
});
if (info == null || info.getRepositoryRootURL() == null) {
exception[0] =
new VcsException("File ''{0}'' is not under version control" + file.getIOFile());
return;
}
final String url = info.getURL() == null ? null : info.getURL().toString();
String relativeUrl = url;
final SVNURL repoRootURL = info.getRepositoryRootURL();
final String root = repoRootURL.toString();
if (url != null && url.startsWith(root)) {
relativeUrl = url.substring(root.length());
}
if (indicator != null) {
indicator.setText2(SvnBundle.message("progress.text2.changes.establishing.connection", url));
}
final SVNRevision pegRevision = info.getRevision();
SVNLogClient client = myVcs.createLogClient();
final boolean supports15 = SvnUtil.checkRepositoryVersion15(myVcs, url);
supports15Ref.set(supports15);
client.doLog(
new File[] {new File(file.getIOFile().getAbsolutePath())},
SVNRevision.HEAD,
SVNRevision.create(1),
SVNRevision.UNDEFINED,
false,
true,
supports15,
0,
null,
new MyLogEntryHandler(
myVcs, url, pegRevision, relativeUrl, result, repoRootURL, file.getCharset()));
}
@CalledInAwt
public static void refreshPassedFilesAndMoveToChangelist(
@NotNull final Project project,
final Collection<FilePath> directlyAffected,
final Collection<VirtualFile> indirectlyAffected,
final Consumer<Collection<FilePath>> targetChangelistMover) {
final LocalFileSystem lfs = LocalFileSystem.getInstance();
for (FilePath filePath : directlyAffected) {
lfs.refreshAndFindFileByIoFile(filePath.getIOFile());
}
if (project.isDisposed()) return;
final ChangeListManager changeListManager = ChangeListManager.getInstance(project);
if (!directlyAffected.isEmpty() && targetChangelistMover != null) {
changeListManager.invokeAfterUpdate(
new Runnable() {
@Override
public void run() {
targetChangelistMover.consume(directlyAffected);
}
},
InvokeAfterUpdateMode.SYNCHRONOUS_CANCELLABLE,
VcsBundle.message("change.lists.manager.move.changes.to.list"),
new Consumer<VcsDirtyScopeManager>() {
@Override
public void consume(final VcsDirtyScopeManager vcsDirtyScopeManager) {
markDirty(vcsDirtyScopeManager, directlyAffected, indirectlyAffected);
}
},
null);
} else {
markDirty(VcsDirtyScopeManager.getInstance(project), directlyAffected, indirectlyAffected);
}
}
public void go(final FilePath rootPath, final SVNDepth depth) throws SVNException {
final MyItem root =
new MyItem(myProject, rootPath, depth, myPartner.createStatusClient(), false);
myQueue.add(root);
while (!myQueue.isEmpty()) {
myPartner.checkCanceled();
final MyItem item = myQueue.removeFirst();
final FilePath path = item.getPath();
final File ioFile = path.getIOFile();
if (path.isDirectory()) {
myHandler.setCurrentItem(item);
try {
item.getClient(ioFile)
.doStatus(
ioFile,
SVNRevision.WORKING,
item.getDepth(),
false,
false,
true,
false,
myHandler,
null);
myHandler.checkIfCopyRootWasReported();
} catch (SVNException e) {
if (e.getErrorMessage().getErrorCode() == SVNErrorCode.WC_NOT_DIRECTORY) {
final VirtualFile virtualFile = path.getVirtualFile();
if (virtualFile != null) {
if (myPartner.isExcluded(virtualFile)) return;
// self is unversioned
myReceiver.processUnversioned(virtualFile);
processRecursively(virtualFile, item.getDepth());
}
} else {
throw e;
}
}
} else {
if (item.isIsInnerCopyRoot()) {
// this means that the status of parent directory had already been checked and is
// unversioned;
// to avoid SVN exception on status query to unversioned directory; and since we already
// know then that the file
// status is "unversioned" -> just register the unversioned file
if (path.getVirtualFile() != null) {
myReceiver.processUnversioned(path.getVirtualFile());
}
} else {
// just file
final SVNStatus status = item.getClient().doStatus(ioFile, false, false);
myReceiver.process(path, status);
}
}
}
}
public List<File> getAffectedPaths() {
final SortedSet<FilePath> set = myIdx.getAffectedPaths();
final List<File> result = new ArrayList<File>(set.size());
for (FilePath path : set) {
result.add(path.getIOFile());
}
return result;
}
private String getDiffWindowTitle(final Change change) {
if (change.isMoved() || change.isRenamed()) {
final FilePath beforeFilePath = ChangesUtil.getBeforePath(change);
final FilePath afterFilePath = ChangesUtil.getAfterPath(change);
final String beforePath =
beforeFilePath == null ? "" : beforeFilePath.getIOFile().getAbsolutePath();
final String afterPath =
afterFilePath == null ? "" : afterFilePath.getIOFile().getAbsolutePath();
return SvnBundle.message(
"action.Subversion.properties.difference.diff.for.move.title", beforePath, afterPath);
} else {
return SvnBundle.message(
"action.Subversion.properties.difference.diff.title",
ChangesUtil.getFilePath(change).getIOFile().getAbsolutePath());
}
}
private boolean isUnderOldDir(Change change, FilePath path) {
if (change.getBeforeRevision() != null) {
final boolean isUnder =
FileUtil.isAncestor(
path.getIOFile(), change.getBeforeRevision().getFile().getIOFile(), true);
if (isUnder) {
return true;
}
}
if (change.getAfterRevision() != null) {
final boolean isUnder =
FileUtil.isAncestor(
path.getIOFile(), change.getAfterRevision().getFile().getIOFile(), true);
if (isUnder) {
return isUnder;
}
}
return false;
}
private void processDeletedFiles(Project project) {
final List<Pair<FilePath, WorkingCopyFormat>> deletedFiles =
new ArrayList<Pair<FilePath, WorkingCopyFormat>>();
final Collection<FilePath> filesToProcess = new ArrayList<FilePath>();
List<VcsException> exceptions = new ArrayList<VcsException>();
final AbstractVcsHelper vcsHelper = AbstractVcsHelper.getInstance(project);
try {
fillDeletedFiles(project, deletedFiles, filesToProcess);
if (deletedFiles.isEmpty() && filesToProcess.isEmpty() || myUndoingMove) return;
SvnVcs vcs = SvnVcs.getInstance(project);
final VcsShowConfirmationOption.Value value = vcs.getDeleteConfirmation().getValue();
if (value != VcsShowConfirmationOption.Value.DO_NOTHING_SILENTLY) {
if (!deletedFiles.isEmpty()) {
final Collection<FilePath> confirmed =
promptAboutDeletion(deletedFiles, vcs, value, vcsHelper);
if (confirmed != null) {
filesToProcess.addAll(confirmed);
}
}
if (filesToProcess != null && !filesToProcess.isEmpty()) {
runInBackground(
project,
"Deleting files from Subversion",
createDeleteRunnable(project, vcs, filesToProcess, exceptions));
}
final List<FilePath> deletedFilesFiles =
ObjectsConvertor.convert(
deletedFiles,
new Convertor<Pair<FilePath, WorkingCopyFormat>, FilePath>() {
@Override
public FilePath convert(Pair<FilePath, WorkingCopyFormat> o) {
return o.getFirst();
}
});
for (FilePath file : deletedFilesFiles) {
final FilePath parent = file.getParentPath();
if (parent != null) {
myFilesToRefresh.add(parent.getVirtualFile());
}
}
if (filesToProcess != null) {
deletedFilesFiles.removeAll(filesToProcess);
}
for (FilePath file : deletedFilesFiles) {
FileUtil.delete(file.getIOFile());
}
}
} catch (SVNException e) {
exceptions.add(new VcsException(e));
}
if (!exceptions.isEmpty()) {
vcsHelper.showErrors(exceptions, SvnBundle.message("delete.files.errors.title"));
}
}
protected byte[] getUpToDateBinaryContent() throws VcsException {
File file = myFile.getIOFile();
File lock = new File(file.getParentFile(), SvnUtil.PATH_TO_LOCK_FILE);
if (lock.exists()) {
throw new VcsException(
"Can not access file base revision contents: administrative area is locked");
}
return SvnUtil.getFileContents(
myVcs,
SvnTarget.fromFile(file),
myUseBaseRevision ? SVNRevision.BASE : myRevision,
SVNRevision.UNDEFINED);
}
private File[] getSelectedIoFiles() {
final List<Change> changes = getSelectedChanges();
final List<File> files = new ArrayList<>();
for (Change change : changes) {
final ContentRevision afterRevision = change.getAfterRevision();
if (afterRevision != null) {
final FilePath file = afterRevision.getFile();
final File ioFile = file.getIOFile();
files.add(ioFile);
}
}
return files.toArray(new File[files.size()]);
}
private static void correctListForRevision(
final ProjectLevelVcsManager plVcsManager,
final ContentRevision revision,
final SVNChangelistClient client,
final String name) {
if (revision != null) {
final FilePath path = revision.getFile();
final AbstractVcs vcs = plVcsManager.getVcsFor(path);
if (vcs != null && VCS_NAME.equals(vcs.getName())) {
try {
client.doAddToChangelist(new File[] {path.getIOFile()}, SVNDepth.EMPTY, name, null);
} catch (SVNException e) {
// left in default list
}
}
}
}
@Override
public boolean fileExistsInVcs(FilePath path) {
File file = path.getIOFile();
try {
SVNStatus status = createStatusClient().doStatus(file, false);
if (status != null) {
if (svnStatusIs(status, SVNStatusType.STATUS_ADDED)) {
return status.isCopied();
}
return !(svnStatusIsUnversioned(status)
|| svnStatusIs(status, SVNStatusType.STATUS_IGNORED)
|| svnStatusIs(status, SVNStatusType.STATUS_OBSTRUCTED));
}
} catch (SVNException e) {
//
}
return false;
}
/**
* Return a git root for the file path (the parent directory with ".git" subdirectory)
*
* @param filePath a file path
* @return git root for the file or null if the file is not under git
* @deprecated because uses the java.io.File.
* @use GitRepositoryManager#getRepositoryForFile().
*/
@Deprecated
@Nullable
public static VirtualFile getGitRootOrNull(@NotNull final FilePath filePath) {
return getGitRootOrNull(filePath.getIOFile());
}
@Nullable
public RepositoryLocation getLocationFor(final FilePath root) {
final ProgressIndicator progress = ProgressManager.getInstance().getProgressIndicator();
final String url = SvnUtil.getExactLocation(myVcs, root.getIOFile());
return url == null ? null : new SvnRepositoryLocation(url);
}