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"));
}
}
private void checkOverwrites(final Project project) {
final Collection<AddedFileInfo> addedFileInfos = myAddedFiles.get(project);
final Collection<File> deletedFiles = myDeletedFiles.get(project);
if (addedFileInfos.isEmpty() || deletedFiles.isEmpty()) return;
final Iterator<AddedFileInfo> iterator = addedFileInfos.iterator();
while (iterator.hasNext()) {
AddedFileInfo addedFileInfo = iterator.next();
final File ioFile = new File(addedFileInfo.myDir.getPath(), addedFileInfo.myName);
if (deletedFiles.remove(ioFile)) {
iterator.remove();
}
}
}
@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);
}
}
// called NOT under ChangeListManagerImpl lock
public void notifyStartProcessingChanges(final VcsModifiableDirtyScope scope) {
final Collection<Change> oldChanges = new ArrayList<Change>();
for (LocalChangeList list : myMap.values()) {
final Collection<Change> affectedChanges =
((LocalChangeListImpl) list).startProcessingChanges(myProject, scope);
if (!affectedChanges.isEmpty()) {
oldChanges.addAll(affectedChanges);
}
}
for (Change change : oldChanges) {
myIdx.changeRemoved(change);
}
// scope should be modified for correct moves tracking
correctScopeForMoves(scope, oldChanges);
myLocallyDeleted.cleanAndAdjustScope(scope);
mySwitchedHolder.cleanAndAdjustScope(scope);
}
private void processAddedFiles(Project project) {
SvnVcs vcs = SvnVcs.getInstance(project);
List<VirtualFile> addedVFiles = new ArrayList<VirtualFile>();
Map<VirtualFile, File> copyFromMap = new HashMap<VirtualFile, File>();
final Set<VirtualFile> recursiveItems = new HashSet<VirtualFile>();
fillAddedFiles(project, vcs, addedVFiles, copyFromMap, recursiveItems);
if (addedVFiles.isEmpty()) return;
final VcsShowConfirmationOption.Value value = vcs.getAddConfirmation().getValue();
if (value != VcsShowConfirmationOption.Value.DO_NOTHING_SILENTLY) {
final AbstractVcsHelper vcsHelper = AbstractVcsHelper.getInstance(project);
final Collection<VirtualFile> filesToProcess =
promptAboutAddition(vcs, addedVFiles, value, vcsHelper);
if (filesToProcess != null && !filesToProcess.isEmpty()) {
final List<VcsException> exceptions = new ArrayList<VcsException>();
runInBackground(
project,
"Adding files to Subversion",
createAdditionRunnable(project, vcs, copyFromMap, filesToProcess, exceptions));
if (!exceptions.isEmpty()) {
vcsHelper.showErrors(exceptions, SvnBundle.message("add.files.errors.title"));
}
}
}
}
@CalledInAwt
public static ApplyPatchStatus executePatchGroup(
final Collection<PatchApplier> group, final LocalChangeList localChangeList) {
if (group.isEmpty()) return ApplyPatchStatus.SUCCESS; // ?
final Project project = group.iterator().next().myProject;
ApplyPatchStatus result = ApplyPatchStatus.SUCCESS;
for (PatchApplier patchApplier : group) {
result = ApplyPatchStatus.and(result, patchApplier.nonWriteActionPreCheck());
}
final Label beforeLabel = LocalHistory.getInstance().putSystemLabel(project, "Before patch");
final TriggerAdditionOrDeletion trigger = new TriggerAdditionOrDeletion(project);
final Ref<ApplyPatchStatus> refStatus = new Ref<>(result);
try {
CommandProcessor.getInstance()
.executeCommand(
project,
new Runnable() {
@Override
public void run() {
for (PatchApplier applier : group) {
refStatus.set(ApplyPatchStatus.and(refStatus.get(), applier.createFiles()));
applier.addSkippedItems(trigger);
}
trigger.prepare();
if (refStatus.get() == ApplyPatchStatus.SUCCESS) {
// all pre-check results are valuable only if not successful; actual status we
// can receive after executeWritable
refStatus.set(null);
}
for (PatchApplier applier : group) {
refStatus.set(ApplyPatchStatus.and(refStatus.get(), applier.executeWritable()));
if (refStatus.get() == ApplyPatchStatus.ABORT) break;
}
}
},
VcsBundle.message("patch.apply.command"),
null);
} finally {
VcsFileListenerContextHelper.getInstance(project).clearContext();
LocalHistory.getInstance().putSystemLabel(project, "After patch");
}
result = refStatus.get();
result = result == null ? ApplyPatchStatus.FAILURE : result;
trigger.processIt();
final Set<FilePath> directlyAffected = new HashSet<>();
final Set<VirtualFile> indirectlyAffected = new HashSet<>();
for (PatchApplier applier : group) {
directlyAffected.addAll(applier.getDirectlyAffected());
indirectlyAffected.addAll(applier.getIndirectlyAffected());
}
directlyAffected.addAll(trigger.getAffected());
final Consumer<Collection<FilePath>> mover =
localChangeList == null ? null : createMover(project, localChangeList);
refreshPassedFilesAndMoveToChangelist(project, directlyAffected, indirectlyAffected, mover);
if (result == ApplyPatchStatus.FAILURE) {
suggestRollback(project, group, beforeLabel);
} else if (result == ApplyPatchStatus.ABORT) {
rollbackUnderProgress(project, project.getBaseDir(), beforeLabel);
}
showApplyStatus(project, result);
return result;
}