@NotNull public static List<VcsDirectoryMapping> addMapping( @NotNull List<VcsDirectoryMapping> existingMappings, @NotNull String path, @NotNull String vcs) { List<VcsDirectoryMapping> mappings = new ArrayList<VcsDirectoryMapping>(existingMappings); for (Iterator<VcsDirectoryMapping> iterator = mappings.iterator(); iterator.hasNext(); ) { VcsDirectoryMapping mapping = iterator.next(); if (mapping.isDefaultMapping() && StringUtil.isEmptyOrSpaces(mapping.getVcs())) { LOG.debug("Removing <Project> -> <None> mapping"); iterator.remove(); } else if (FileUtil.pathsEqual(mapping.getDirectory(), path)) { if (!StringUtil.isEmptyOrSpaces(mapping.getVcs())) { LOG.warn( "Substituting existing mapping [" + path + "] -> [" + mapping.getVcs() + "] with [" + vcs + "]"); } else { LOG.debug("Removing [" + path + "] -> <None> mapping"); } iterator.remove(); } } mappings.add(new VcsDirectoryMapping(path, vcs)); return mappings; }
private static void filterOutInvalid(final Collection<VirtualFile> files) { for (Iterator<VirtualFile> iterator = files.iterator(); iterator.hasNext(); ) { final VirtualFile file = iterator.next(); if (!file.isValid() || !file.exists()) { LOG.info("Refresh root is not valid: " + file.getPath()); iterator.remove(); } } }
private List<Change> filterOutBinary(List<Change> paths) { List<Change> result = null; for (Iterator<Change> iterator = paths.iterator(); iterator.hasNext(); ) { final Change change = iterator.next(); if (ChangesUtil.isBinaryChange(change)) { result = (result == null ? new SmartList<Change>() : result); result.add(change); iterator.remove(); } } return result; }
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(); } } }
public Map<VirtualFile, RepositoryLocation> getRoots() { myContentRoots = myPlManager.getRootsUnderVcs(myVcs); List<VirtualFile> roots = new ArrayList<>(); final List<VcsDirectoryMapping> mappings = myPlManager.getDirectoryMappings(myVcs); for (VcsDirectoryMapping mapping : mappings) { if (mapping.isDefaultMapping()) { if (myVcs.equals(myPlManager.getVcsFor(myProject.getBaseDir()))) { roots.add(myProject.getBaseDir()); } } else { VirtualFile newFile = LocalFileSystem.getInstance().findFileByPath(mapping.getDirectory()); if (newFile == null) { newFile = LocalFileSystem.getInstance().refreshAndFindFileByPath(mapping.getDirectory()); } if (newFile != null) { roots.add(newFile); } else { LOG.info("Can not file virtual file for root: " + mapping.getDirectory()); } } } ContainerUtil.addAll(roots, myContentRoots); final Map<VirtualFile, RepositoryLocation> result = new HashMap<>(); for (Iterator<VirtualFile> iterator = roots.iterator(); iterator.hasNext(); ) { final VirtualFile vf = iterator.next(); final RepositoryLocation location = myLocationCache.getLocation(myVcs, VcsUtil.getFilePath(vf), false); if (location != null) { result.put(vf, location); } else { iterator.remove(); } } roots = myVcs.filterUniqueRoots(roots, IntoSelfVirtualFileConvertor.getInstance()); result.keySet().retainAll(roots); logRoots(roots); return result; }
private static List<TextFilePatch> loadTextPatches( final Project project, final ShelvedChangeList changeList, final List<ShelvedChange> changes, final List<FilePatch> remainingPatches, final CommitContext commitContext) throws IOException, PatchSyntaxException { final List<TextFilePatch> textFilePatches; textFilePatches = loadPatches(project, changeList.PATH, commitContext); if (changes != null) { final Iterator<TextFilePatch> iterator = textFilePatches.iterator(); while (iterator.hasNext()) { TextFilePatch patch = iterator.next(); if (!needUnshelve(patch, changes)) { remainingPatches.add(patch); iterator.remove(); } } } return textFilePatches; }
private void recycleChangeList( final ShelvedChangeList listCopy, final ShelvedChangeList newList) { if (newList != null) { for (Iterator<ShelvedBinaryFile> shelvedChangeListIterator = listCopy.getBinaryFiles().iterator(); shelvedChangeListIterator.hasNext(); ) { final ShelvedBinaryFile binaryFile = shelvedChangeListIterator.next(); for (ShelvedBinaryFile newBinary : newList.getBinaryFiles()) { if (Comparing.equal(newBinary.BEFORE_PATH, binaryFile.BEFORE_PATH) && Comparing.equal(newBinary.AFTER_PATH, binaryFile.AFTER_PATH)) { shelvedChangeListIterator.remove(); } } } for (Iterator<ShelvedChange> iterator = listCopy.getChanges(myProject).iterator(); iterator.hasNext(); ) { final ShelvedChange change = iterator.next(); for (ShelvedChange newChange : newList.getChanges(myProject)) { if (Comparing.equal(change.getBeforePath(), newChange.getBeforePath()) && Comparing.equal(change.getAfterPath(), newChange.getAfterPath())) { iterator.remove(); } } } // needed only if partial unshelve try { final CommitContext commitContext = new CommitContext(); final List<FilePatch> patches = new ArrayList<FilePatch>(); for (ShelvedChange change : listCopy.getChanges(myProject)) { patches.add(change.loadFilePatch(myProject, commitContext)); } writePatchesToFile(myProject, listCopy.PATH, patches, commitContext); } catch (IOException e) { LOG.info(e); // left file as is } catch (PatchSyntaxException e) { LOG.info(e); // left file as is } } if ((!listCopy.getBinaryFiles().isEmpty()) || (!listCopy.getChanges(myProject).isEmpty())) { listCopy.setRecycled(true); myRecycledShelvedChangeLists.add(listCopy); notifyStateChanged(); } }