private Change[] getLeadSelection() {
final Set<Change> changes = new LinkedHashSet<Change>();
final TreePath[] paths = getSelectionPaths();
if (paths == null) return new Change[0];
for (TreePath path : paths) {
ChangesBrowserNode node = (ChangesBrowserNode) path.getLastPathComponent();
if (node instanceof ChangesBrowserChangeNode) {
changes.add(((ChangesBrowserChangeNode) node).getUserObject());
}
}
return changes.toArray(new Change[changes.size()]);
}
private List<FilePath> getSelectedFilePaths(final Object tag) {
Set<FilePath> files = new HashSet<FilePath>();
final TreePath[] paths = getSelectionPaths();
if (paths != null) {
for (TreePath path : paths) {
if (path.getPathCount() > 1) {
ChangesBrowserNode firstNode = (ChangesBrowserNode) path.getPathComponent(1);
if (tag == null || firstNode.getUserObject() == tag) {
ChangesBrowserNode<?> node = (ChangesBrowserNode) path.getLastPathComponent();
files.addAll(node.getAllFilePathsUnder());
}
}
}
}
return new ArrayList<FilePath>(files);
}
private void fillAddedFiles(
Project project,
SvnVcs vcs,
List<VirtualFile> addedVFiles,
Map<VirtualFile, File> copyFromMap,
Set<VirtualFile> recursiveItems) {
final Collection<AddedFileInfo> addedFileInfos = myAddedFiles.remove(project);
final ChangeListManager changeListManager = ChangeListManager.getInstance(project);
for (AddedFileInfo addedFileInfo : addedFileInfos) {
final File ioFile = new File(getIOFile(addedFileInfo.myDir), addedFileInfo.myName);
VirtualFile addedFile = addedFileInfo.myDir.findChild(addedFileInfo.myName);
if (addedFile == null) {
addedFile = myLfs.refreshAndFindFileByIoFile(ioFile);
}
if (addedFile != null) {
final SVNStatus fileStatus = getFileStatus(vcs, ioFile);
if (fileStatus == null || !SvnVcs.svnStatusIs(fileStatus, SVNStatusType.STATUS_IGNORED)) {
boolean isIgnored = changeListManager.isIgnoredFile(addedFile);
if (!isIgnored) {
addedVFiles.add(addedFile);
copyFromMap.put(addedFile, addedFileInfo.myCopyFrom);
if (addedFileInfo.myRecursive) {
recursiveItems.add(addedFile);
}
}
}
}
}
}
@NotNull
private ChangeList[] getSelectedChangeLists() {
Set<ChangeList> lists = new HashSet<ChangeList>();
final TreePath[] paths = getSelectionPaths();
if (paths == null) return new ChangeList[0];
for (TreePath path : paths) {
ChangesBrowserNode node = (ChangesBrowserNode) path.getLastPathComponent();
final Object userObject = node.getUserObject();
if (userObject instanceof ChangeList) {
lists.add((ChangeList) userObject);
}
}
return lists.toArray(new ChangeList[lists.size()]);
}
private List<LocallyDeletedChange> getSelectedLocallyDeletedChanges() {
Set<LocallyDeletedChange> files = new HashSet<LocallyDeletedChange>();
final TreePath[] paths = getSelectionPaths();
if (paths != null) {
for (TreePath path : paths) {
if (path.getPathCount() > 1) {
ChangesBrowserNode firstNode = (ChangesBrowserNode) path.getPathComponent(1);
if (firstNode.getUserObject() == TreeModelBuilder.LOCALLY_DELETED_NODE) {
ChangesBrowserNode<?> node = (ChangesBrowserNode) path.getLastPathComponent();
final List<LocallyDeletedChange> objectsUnder =
node.getAllObjectsUnder(LocallyDeletedChange.class);
files.addAll(objectsUnder);
}
}
}
}
return new ArrayList<LocallyDeletedChange>(files);
}
@Nullable
private Intersection checkIntersection(
@Nullable final List<CommittedChangeList> lists, List<LocalChangeList> localChangeLists) {
if (lists == null || lists.isEmpty()) {
return null;
}
final Set<FilePath> mergePaths = new HashSet<FilePath>();
for (CommittedChangeList list : lists) {
final SvnChangeList svnList = (SvnChangeList) list;
final List<String> paths = new ArrayList<String>(svnList.getAddedPaths());
paths.addAll(svnList.getChangedPaths());
paths.addAll(svnList.getDeletedPaths());
for (String path : paths) {
final File localPath = getLocalPath(path);
if (localPath != null) {
mergePaths.add(new FilePathImpl(localPath, false));
}
}
}
final Intersection intersection = new Intersection();
for (LocalChangeList localChangeList : localChangeLists) {
final Collection<Change> localChanges = localChangeList.getChanges();
for (Change localChange : localChanges) {
final FilePath before =
localChange.getBeforeRevision() == null
? null
: localChange.getBeforeRevision().getFile();
final FilePath after =
localChange.getAfterRevision() == null
? null
: localChange.getAfterRevision().getFile();
if ((before != null && mergePaths.contains(before))
|| (after != null && mergePaths.contains(after))) {
intersection.add(localChangeList.getName(), localChangeList.getComment(), localChange);
}
}
}
return intersection;
}
private void baseRevisionsOfDvcsIntoContext(
List<Change> textChanges, CommitContext commitContext) {
ProjectLevelVcsManager vcsManager = ProjectLevelVcsManager.getInstance(myProject);
if (vcsManager.dvcsUsedInProject()
&& VcsConfiguration.getInstance(myProject).INCLUDE_TEXT_INTO_SHELF) {
final Set<Change> big = SelectFilesToAddTextsToPatchPanel.getBig(textChanges);
final ArrayList<FilePath> toKeep = new ArrayList<FilePath>();
for (Change change : textChanges) {
if (change.getBeforeRevision() == null || change.getAfterRevision() == null) continue;
if (big.contains(change)) continue;
FilePath filePath = ChangesUtil.getFilePath(change);
final AbstractVcs vcs = vcsManager.getVcsFor(filePath);
if (vcs != null && VcsType.distibuted.equals(vcs.getType())) {
toKeep.add(filePath);
}
}
commitContext.putUserData(BaseRevisionTextPatchEP.ourPutBaseRevisionTextKey, true);
commitContext.putUserData(BaseRevisionTextPatchEP.ourBaseRevisionPaths, toKeep);
}
}
@NotNull
public Change[] getSelectedChanges() {
Set<Change> changes = new LinkedHashSet<Change>();
final TreePath[] paths = getSelectionPaths();
if (paths == null) {
return new Change[0];
}
for (TreePath path : paths) {
ChangesBrowserNode<?> node = (ChangesBrowserNode) path.getLastPathComponent();
changes.addAll(node.getAllChangesUnder());
}
if (changes.isEmpty()) {
final List<VirtualFile> selectedModifiedWithoutEditing = getSelectedModifiedWithoutEditing();
if (selectedModifiedWithoutEditing != null && !selectedModifiedWithoutEditing.isEmpty()) {
for (VirtualFile file : selectedModifiedWithoutEditing) {
AbstractVcs vcs = ProjectLevelVcsManager.getInstance(myProject).getVcsFor(file);
if (vcs == null) continue;
final VcsCurrentRevisionProxy before =
VcsCurrentRevisionProxy.create(file, myProject, vcs.getKeyInstanceMethod());
if (before != null) {
ContentRevision afterRevision = new CurrentContentRevision(new FilePathImpl(file));
changes.add(new Change(before, afterRevision, FileStatus.HIJACKED));
}
}
}
}
return changes.toArray(new Change[changes.size()]);
}
@NotNull
public List<VirtualFile> getAffectedFiles() {
final Set<VirtualFile> result = ContainerUtil.newLinkedHashSet();
for (LocalChangeList list : myMap.values()) {
for (Change change : list.getChanges()) {
final ContentRevision before = change.getBeforeRevision();
final ContentRevision after = change.getAfterRevision();
if (before != null) {
final VirtualFile file = before.getFile().getVirtualFile();
if (file != null) {
result.add(file);
}
}
if (after != null) {
final VirtualFile file = after.getFile().getVirtualFile();
if (file != null) {
result.add(file);
}
}
}
}
return new ArrayList<VirtualFile>(result);
}
private Collection<FilePath> chooseBinaryFiles(List<Change> converted, Set<FilePath> paths) {
String singleMessage = "";
if (paths.size() == 1) {
final Change change = converted.get(0);
final FileStatus status = change.getFileStatus();
final FilePath path = ChangesUtil.getFilePath(change);
final String stringPath = TreeConflictRefreshablePanel.filePath(path);
if (FileStatus.DELETED.equals(status)) {
singleMessage = "Delete binary file " + stringPath + " (according to theirs changes)?";
} else if (FileStatus.ADDED.equals(status)) {
singleMessage = "Create binary file " + stringPath + " (according to theirs changes)?";
} else {
singleMessage =
"Apply changes to binary file " + stringPath + " (according to theirs changes)?";
}
}
return AbstractVcsHelper.getInstance(myVcs.getProject())
.selectFilePathsToProcess(
new ArrayList<FilePath>(paths),
TreeConflictRefreshablePanel.TITLE,
"Select binary files to patch",
TreeConflictRefreshablePanel.TITLE,
singleMessage,
new VcsShowConfirmationOption() {
@Override
public Value getValue() {
return null;
}
@Override
public void setValue(Value value) {}
@Override
public boolean isPersistent() {
return false;
}
});
}
public boolean updateStep() {
final MultiMap<VcsRoot, String> dirty = new MultiMap<VcsRoot, String>();
final long oldPoint =
System.currentTimeMillis()
- (myVcsConfiguration.CHANGED_ON_SERVER_INTERVAL > 0
? myVcsConfiguration.CHANGED_ON_SERVER_INTERVAL * 60000
: DISCRETE);
synchronized (myLock) {
// just copies myQueries MultiMap to dirty MultiMap
for (VcsRoot root : myQueries.keySet()) {
final Collection<String> collection = myQueries.get(root);
for (String s : collection) {
dirty.putValue(root, s);
}
}
myQueries.clear();
// collect roots for which cache update should be performed (by timestamp)
final Set<VcsRoot> roots = new HashSet<VcsRoot>();
for (Map.Entry<VcsRoot, Long> entry : myTs.entrySet()) {
// ignore timestamp, as still remote changes checking is required
// TODO: why not to add in roots anyway??? - as dirty is still checked when adding myChanged
// files.
if (!dirty.get(entry.getKey()).isEmpty()) continue;
// update only if timeout expired
final Long ts = entry.getValue();
if ((ts == null) || (oldPoint > ts)) {
roots.add(entry.getKey());
}
}
// Add dirty files from those vcs roots, that
// - needs to be update by timestamp criteria
// - that already contain files for update through manually added requests
for (Map.Entry<String, Pair<Boolean, VcsRoot>> entry : myChanged.entrySet()) {
final VcsRoot vcsRoot = entry.getValue().getSecond();
if ((!dirty.get(vcsRoot).isEmpty()) || roots.contains(vcsRoot)) {
dirty.putValue(vcsRoot, entry.getKey());
}
}
}
if (dirty.isEmpty()) return false;
final Map<String, Pair<Boolean, VcsRoot>> results =
new HashMap<String, Pair<Boolean, VcsRoot>>();
for (VcsRoot vcsRoot : dirty.keySet()) {
// todo - actually it means nothing since the only known VCS to use this scheme is Git and now
// it always allow
// todo - background operations. when it changes, develop more flexible behavior here
if (!vcsRoot.getVcs().isVcsBackgroundOperationsAllowed(vcsRoot.getPath())) continue;
final TreeDiffProvider provider = vcsRoot.getVcs().getTreeDiffProvider();
if (provider == null) continue;
final Collection<String> paths = dirty.get(vcsRoot);
final Collection<String> remotelyChanged =
provider.getRemotelyChanged(vcsRoot.getPath(), paths);
for (String path : paths) {
// TODO: Contains invoked for each file - better to use Set (implementations just use List)
// TODO: Why to store boolean for changed or not - why not just remove such values from
// myChanged???
results.put(path, new Pair<Boolean, VcsRoot>(remotelyChanged.contains(path), vcsRoot));
}
}
final long curTime = System.currentTimeMillis();
synchronized (myLock) {
myChanged.putAll(results);
for (VcsRoot vcsRoot : dirty.keySet()) {
myTs.put(vcsRoot, curTime);
}
}
return true;
}
static {
ourStatusesForUndoMove.add(SVNStatusType.STATUS_ADDED);
}
@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;
}
public boolean updateStep(final AtomicSectionsAware atomicSectionsAware) {
final MultiMap<VcsRoot, String> dirty = new MultiMap<VcsRoot, String>();
final long oldPoint =
System.currentTimeMillis()
- (myVcsConfiguration.CHANGED_ON_SERVER_INTERVAL > 0
? myVcsConfiguration.CHANGED_ON_SERVER_INTERVAL * 60000
: DISCRETE);
synchronized (myLock) {
for (VcsRoot root : myQueries.keySet()) {
final Collection<String> collection = myQueries.get(root);
for (String s : collection) {
dirty.putValue(root, s);
}
}
myQueries.clear();
final Set<VcsRoot> roots = new HashSet<VcsRoot>();
for (Map.Entry<VcsRoot, Long> entry : myTs.entrySet()) {
if (!dirty.get(entry.getKey()).isEmpty()) continue;
final Long ts = entry.getValue();
if ((ts == null) || (oldPoint > ts)) {
roots.add(entry.getKey());
}
}
for (Map.Entry<String, Pair<Boolean, VcsRoot>> entry : myChanged.entrySet()) {
final VcsRoot vcsRoot = entry.getValue().getSecond();
if ((!dirty.get(vcsRoot).isEmpty()) || roots.contains(vcsRoot)) {
dirty.putValue(vcsRoot, entry.getKey());
}
}
}
if (dirty.isEmpty()) return false;
final Map<String, Pair<Boolean, VcsRoot>> results =
new HashMap<String, Pair<Boolean, VcsRoot>>();
for (VcsRoot vcsRoot : dirty.keySet()) {
atomicSectionsAware.checkShouldExit();
// todo - actually it means nothing since the only known VCS to use this scheme is Git and now
// it always allow
// todo - background operations. when it changes, develop more flexible behavior here
if (!vcsRoot.vcs.isVcsBackgroundOperationsAllowed(vcsRoot.path)) continue;
final TreeDiffProvider provider = vcsRoot.vcs.getTreeDiffProvider();
if (provider == null) continue;
final Collection<String> paths = dirty.get(vcsRoot);
final Collection<String> remotelyChanged = provider.getRemotelyChanged(vcsRoot.path, paths);
for (String path : paths) {
results.put(path, new Pair<Boolean, VcsRoot>(remotelyChanged.contains(path), vcsRoot));
}
}
final long curTime = System.currentTimeMillis();
synchronized (myLock) {
myChanged.putAll(results);
for (VcsRoot vcsRoot : dirty.keySet()) {
myTs.put(vcsRoot, curTime);
}
}
return true;
}
