private void executeDelete(@NotNull VirtualFile file) {
if (!file.exists()) {
LOG.error("Deleting a file, which does not exist: " + file.getPath());
return;
}
clearIdCache();
int id = getFileId(file);
final VirtualFile parent = file.getParent();
final int parentId = parent == null ? 0 : getFileId(parent);
if (parentId == 0) {
String rootUrl =
normalizeRootUrl(file.getPath(), (NewVirtualFileSystem) file.getFileSystem());
myRootsLock.writeLock().lock();
try {
myRoots.remove(rootUrl);
myRootsById.remove(id);
FSRecords.deleteRootRecord(id);
} finally {
myRootsLock.writeLock().unlock();
}
} else {
removeIdFromParentList(parentId, id, parent, file);
VirtualDirectoryImpl directory = (VirtualDirectoryImpl) file.getParent();
assert directory != null : file;
directory.removeChild(file);
}
FSRecords.deleteRecordRecursively(id);
invalidateSubtree(file);
}
@Override
public void saveChangedProjectFile(final VirtualFile file, final Project project) {
if (file.exists()) {
copyToTemp(file);
}
registerProjectToReload(project, file, null);
}
/**
* Scroll to the error specified by the given tree path, or do nothing if no error is specified.
*
* @param treePath the tree path to scroll to.
*/
private void scrollToError(final TreePath treePath) {
final DefaultMutableTreeNode treeNode =
(DefaultMutableTreeNode) treePath.getLastPathComponent();
if (treeNode == null || !(treeNode.getUserObject() instanceof ResultTreeNode)) {
return;
}
final ResultTreeNode nodeInfo = (ResultTreeNode) treeNode.getUserObject();
if (nodeInfo.getFile() == null || nodeInfo.getProblem() == null) {
return; // no problem here :-)
}
final VirtualFile virtualFile = nodeInfo.getFile().getVirtualFile();
if (virtualFile == null || !virtualFile.exists()) {
return;
}
final FileEditorManager fileEditorManager = FileEditorManager.getInstance(project);
final FileEditor[] editor = fileEditorManager.openFile(virtualFile, true);
if (editor.length > 0 && editor[0] instanceof TextEditor) {
final LogicalPosition problemPos =
new LogicalPosition(Math.max(lineFor(nodeInfo) - 1, 0), Math.max(columnFor(nodeInfo), 0));
final Editor textEditor = ((TextEditor) editor[0]).getEditor();
textEditor.getCaretModel().moveToLogicalPosition(problemPos);
textEditor.getScrollingModel().scrollToCaret(ScrollType.CENTER);
}
}
private void saveChangedProjectFile(
final VirtualFile file, @Nullable final Project project, final StateStorage storage) {
if (file.exists()) {
copyToTemp(file);
}
registerProjectToReload(project, file, storage);
}
private void applyChildrenChangeEvents(VirtualFile parent, List<VFileEvent> events) {
final NewVirtualFileSystem delegate = getDelegate(parent);
TIntArrayList childrenIdsUpdated = new TIntArrayList();
List<VirtualFile> childrenToBeUpdated = new SmartList<VirtualFile>();
assert parent != null && parent != mySuperRoot;
final int parentId = getFileId(parent);
assert parentId != 0;
TIntHashSet parentChildrenIds = new TIntHashSet(FSRecords.list(parentId));
boolean hasRemovedChildren = false;
for (VFileEvent event : events) {
if (event instanceof VFileCreateEvent) {
String name = ((VFileCreateEvent) event).getChildName();
final VirtualFile fake = new FakeVirtualFile(parent, name);
final FileAttributes attributes = delegate.getAttributes(fake);
if (attributes != null) {
final int childId = createAndFillRecord(delegate, fake, parentId, attributes);
assert parent instanceof VirtualDirectoryImpl : parent;
final VirtualDirectoryImpl dir = (VirtualDirectoryImpl) parent;
VirtualFileSystemEntry child = dir.createChild(name, childId, dir.getFileSystem());
childrenToBeUpdated.add(child);
childrenIdsUpdated.add(childId);
parentChildrenIds.add(childId);
}
} else if (event instanceof VFileDeleteEvent) {
VirtualFile file = ((VFileDeleteEvent) event).getFile();
if (!file.exists()) {
LOG.error("Deleting a file, which does not exist: " + file.getPath());
continue;
}
hasRemovedChildren = true;
int id = getFileId(file);
childrenToBeUpdated.add(file);
childrenIdsUpdated.add(-id);
parentChildrenIds.remove(id);
}
}
FSRecords.updateList(parentId, parentChildrenIds.toArray());
if (hasRemovedChildren) clearIdCache();
VirtualDirectoryImpl parentImpl = (VirtualDirectoryImpl) parent;
for (int i = 0, len = childrenIdsUpdated.size(); i < len; ++i) {
final int childId = childrenIdsUpdated.get(i);
final VirtualFile childFile = childrenToBeUpdated.get(i);
if (childId > 0) {
parentImpl.addChild((VirtualFileSystemEntry) childFile);
} else {
FSRecords.deleteRecordRecursively(-childId);
parentImpl.removeChild(childFile);
invalidateSubtree(childFile);
}
}
}
public void testCopyToPointDir() throws Exception {
File top = createTempDirectory(false);
File sub = IoTestUtil.createTestDir(top, "sub");
File file = IoTestUtil.createTestFile(top, "file.txt", "hi there");
LocalFileSystem lfs = LocalFileSystem.getInstance();
VirtualFile topDir = lfs.refreshAndFindFileByIoFile(top);
assertNotNull(topDir);
VirtualFile sourceFile = lfs.refreshAndFindFileByIoFile(file);
assertNotNull(sourceFile);
VirtualFile parentDir = lfs.refreshAndFindFileByIoFile(sub);
assertNotNull(parentDir);
assertEquals(2, topDir.getChildren().length);
try {
sourceFile.copy(this, parentDir, ".");
fail("Copying a file into a '.' path should have failed");
} catch (IOException e) {
System.out.println(e.getMessage());
}
topDir.refresh(false, true);
assertTrue(topDir.exists());
assertEquals(2, topDir.getChildren().length);
}
public void testSingleFileRootRefresh() throws Exception {
File file = FileUtil.createTempFile("test.", ".txt");
VirtualFile virtualFile = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(file);
assertNotNull(virtualFile);
assertTrue(virtualFile.exists());
assertTrue(virtualFile.isValid());
virtualFile.refresh(false, false);
assertFalse(((VirtualFileSystemEntry) virtualFile).isDirty());
FileUtil.delete(file);
assertFalse(file.exists());
virtualFile.refresh(false, false);
assertFalse(virtualFile.exists());
assertFalse(virtualFile.isValid());
}
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();
}
}
}
@Override
public void reloadFiles(final VirtualFile... files) {
for (VirtualFile file : files) {
if (file.exists()) {
final Document doc = getCachedDocument(file);
if (doc != null) {
reloadFromDisk(doc);
}
}
}
}
private static OperationStatus createResultStatus(final VirtualFile[] files) {
List<VirtualFile> readOnlyFiles = new ArrayList<VirtualFile>();
for (VirtualFile file : files) {
if (file.exists()) {
if (!file.isWritable()) {
readOnlyFiles.add(file);
}
}
}
return new OperationStatusImpl(VfsUtil.toVirtualFileArray(readOnlyFiles));
}
/**
* @return pair.first - file contents (null if file does not exist), pair.second - file line
* separators
*/
@NotNull
public static Pair<byte[], String> loadFile(@Nullable final VirtualFile file) throws IOException {
if (file == null || !file.exists()) {
return NON_EXISTENT_FILE_DATA;
}
byte[] bytes = file.contentsToByteArray();
String lineSeparator = file.getDetectedLineSeparator();
if (lineSeparator == null) {
lineSeparator =
detectLineSeparators(CharsetToolkit.UTF8_CHARSET.decode(ByteBuffer.wrap(bytes)), null)
.getSeparatorString();
}
return Pair.create(bytes, lineSeparator);
}
public static void deleteFile(
@NotNull File file, @NotNull Object requestor, @Nullable VirtualFile virtualFile)
throws IOException {
if (virtualFile == null) {
LOG.warn("Cannot find virtual file " + file.getAbsolutePath());
}
if (virtualFile == null) {
if (file.exists()) {
FileUtil.delete(file);
}
} else if (virtualFile.exists()) {
deleteFile(requestor, virtualFile);
}
}
public void setNewBase(final VirtualFile base) {
myBase = base;
myNewContentRevision = null;
myCurrentRevision = null;
myAfterFile = null;
myConflicts = null;
final String beforeName = myPatch.getBeforeName();
if (beforeName != null) {
myIoCurrentBase = PathMerger.getFile(new File(myBase.getPath()), beforeName);
myCurrentBase =
myIoCurrentBase == null ? null : VcsUtil.getVirtualFileWithRefresh(myIoCurrentBase);
myBaseExists = (myCurrentBase != null) && myCurrentBase.exists();
} else {
// creation
final String afterName = myPatch.getAfterName();
myBaseExists = true;
myIoCurrentBase = PathMerger.getFile(new File(myBase.getPath()), afterName);
myCurrentBase = VcsUtil.getVirtualFileWithRefresh(myIoCurrentBase);
}
}
public static void cacheSingleFile(Project project, VirtualFile openFile) {
if (openFile.exists()) {
// cache attributes
PsiManager psiManager = PsiManager.getInstance(project);
if (psiManager == null) return;
PsiFile psiFile = psiManager.findFile(openFile);
if (psiFile == null) return;
FileASTNode astNode = psiFile.getNode();
if (astNode == null) return;
HashSet<String> rs = findAllVariables(astNode.getChildren(null), PerlTypes.VARIABLE, false);
if (rs == null) return;
for (String str : rs) {
addCachedVariables(null, str);
}
// cache subs
ArrayList<Package> packages = ModulesContainer.getPackageListFromFile(openFile.getPath());
for (int i = 0; i < packages.size(); i++) {
ArrayList<Sub> subs = packages.get(i).getAllSubs();
for (int j = 0; j < subs.size(); j++) {
addCachedSub(null, subs.get(j));
}
}
}
}
public void patch(final FlooPatch res) {
final TextBuf b = this;
Flog.info("Got _on_patch");
String text;
String md5FromDoc;
final Document d;
String oldText = buf;
VirtualFile virtualFile = b.getVirtualFile();
if (virtualFile == null) {
Flog.warn("VirtualFile is null, no idea what do do. Aborting everything %s", this);
getBuf();
return;
}
d = Buf.getDocumentForVirtualFile(virtualFile);
if (d == null) {
Flog.warn("Document not found for %s", virtualFile);
getBuf();
return;
}
String viewText;
if (virtualFile.exists()) {
viewText = d.getText();
if (viewText.equals(oldText)) {
b.forced_patch = false;
} else if (!b.forced_patch) {
b.forced_patch = true;
oldText = viewText;
b.send_patch(viewText);
Flog.warn("Sending force patch for %s. this is dangerous!", b.path);
}
} else {
viewText = oldText;
}
b.cancelTimeout();
String md5Before = DigestUtils.md5Hex(viewText);
if (!md5Before.equals(res.md5_before)) {
Flog.warn("starting md5s don't match for %s. this is dangerous!", b.path);
}
List<diff_match_patch.Patch> patches = dmp.patch_fromText(res.patch);
final Object[] results = dmp.patch_apply((LinkedList<diff_match_patch.Patch>) patches, oldText);
final String patchedContents = (String) results[0];
final boolean[] patchesClean = (boolean[]) results[1];
final FlooPatchPosition[] positions = (FlooPatchPosition[]) results[2];
for (boolean clean : patchesClean) {
if (!clean) {
Flog.log("Patch not clean for %s. Sending get_buf and setting readonly.", d);
getBuf();
return;
}
}
// XXX: If patchedContents have carriage returns this will be a problem:
String md5After = DigestUtils.md5Hex(patchedContents);
if (!md5After.equals(res.md5_after)) {
Flog.info("MD5 after mismatch (ours %s remote %s)", md5After, res.md5_after);
}
if (!d.isWritable()) {
d.setReadOnly(false);
}
if (!ReadonlyStatusHandler.ensureDocumentWritable(context.project, d)) {
Flog.info("Document: %s is not writable.", d);
return;
}
final Editor[] editors = EditorFactory.getInstance().getEditors(d, context.project);
final HashMap<ScrollingModel, Integer[]> original = new HashMap<ScrollingModel, Integer[]>();
for (Editor editor : editors) {
if (editor.isDisposed()) {
continue;
}
ScrollingModel scrollingModel = editor.getScrollingModel();
original.put(
scrollingModel,
new Integer[] {
scrollingModel.getHorizontalScrollOffset(), scrollingModel.getVerticalScrollOffset()
});
}
for (FlooPatchPosition flooPatchPosition : positions) {
int start = Math.max(0, flooPatchPosition.start);
int end_ld = Math.max(start + flooPatchPosition.end, start);
end_ld = Math.min(end_ld, d.getTextLength());
String contents = NEW_LINE.matcher(flooPatchPosition.text).replaceAll("\n");
Throwable e = null;
try {
Listener.flooDisable();
d.replaceString(start, end_ld, contents);
} catch (Throwable exception) {
e = exception;
} finally {
Listener.flooEnable();
}
if (e != null) {
Flog.warn(e);
getBuf();
return;
}
}
text = d.getText();
md5FromDoc = DigestUtils.md5Hex(text);
if (!md5FromDoc.equals(res.md5_after)) {
Flog.info("md5FromDoc mismatch (ours %s remote %s)", md5FromDoc, res.md5_after);
b.setGetBufTimeout();
}
for (Map.Entry<ScrollingModel, Integer[]> entry : original.entrySet()) {
ScrollingModel model = entry.getKey();
Integer[] offsets = entry.getValue();
model.scrollHorizontally(offsets[0]);
model.scrollVertically(offsets[1]);
}
b.set(text, md5FromDoc);
Flog.log("Patched %s", res.path);
}