public void testHardLinks() throws Exception { if (!SystemInfo.isWindows && !SystemInfo.isUnix) { System.err.println(getName() + " skipped: " + SystemInfo.OS_NAME); return; } final boolean safeWrite = GeneralSettings.getInstance().isUseSafeWrite(); final File dir = FileUtil.createTempDirectory("hardlinks.", ".dir", false); final SafeWriteRequestor requestor = new SafeWriteRequestor() {}; try { GeneralSettings.getInstance().setUseSafeWrite(false); final File targetFile = new File(dir, "targetFile"); assertTrue(targetFile.createNewFile()); final File hardLinkFile = IoTestUtil.createHardLink(targetFile.getAbsolutePath(), "hardLinkFile"); final VirtualFile file = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(targetFile); assertNotNull(file); file.setBinaryContent("hello".getBytes("UTF-8"), 0, 0, requestor); assertTrue(file.getLength() > 0); final VirtualFile check = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(hardLinkFile); assertNotNull(check); assertEquals(file.getLength(), check.getLength()); assertEquals("hello", VfsUtilCore.loadText(check)); } finally { GeneralSettings.getInstance().setUseSafeWrite(safeWrite); FileUtil.delete(dir); } }
private void doStuff(String rootDir, String itemRepr, String itemName) throws FileNotFoundException { String patternName = getTestDataPath() + getTestRoot() + getTestName(true) + "/after/" + itemName; File patternFile = new File(patternName); PrintWriter writer; if (!patternFile.exists()) { writer = new PrintWriter(new FileOutputStream(patternFile)); try { writer.print(itemRepr); } finally { writer.close(); } System.out.println("Pattern not found, file " + patternName + " created."); LocalFileSystem.getInstance().refreshAndFindFileByIoFile(patternFile); } File graFile = new File( FileUtil.getTempDirectory() + File.separator + rootDir + File.separator + itemName); writer = new PrintWriter(new FileOutputStream(graFile)); try { writer.print(itemRepr); } finally { writer.close(); } LocalFileSystem.getInstance().refreshAndFindFileByIoFile(graFile); FileDocumentManager.getInstance().saveAllDocuments(); }
protected void setupRootModel( final String testDir, final VirtualFile[] sourceDir, final String sdkName) { VirtualFile projectDir = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(new File(testDir)); assertNotNull("could not find project dir " + testDir, projectDir); sourceDir[0] = projectDir.findChild("src"); if (sourceDir[0] == null) { sourceDir[0] = projectDir; } final ModuleRootManager rootManager = ModuleRootManager.getInstance(myModule); final ModifiableRootModel rootModel = rootManager.getModifiableModel(); rootModel.clear(); // configure source and output path final ContentEntry contentEntry = rootModel.addContentEntry(projectDir); contentEntry.addSourceFolder(sourceDir[0], false); ext_src = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(new File(testDir + "/ext_src")); if (ext_src != null) { contentEntry.addSourceFolder(ext_src, false); } // IMPORTANT! The jdk must be obtained in a way it is obtained in the normal program! // ProjectJdkEx jdk = ProjectJdkTable.getInstance().getInternalJdk(); rootModel.setSdk(getTestProjectSdk()); rootModel.commit(); }
@Nullable public static VirtualFile findRefreshFileOrLog(@NotNull String absolutePath) { VirtualFile file = LocalFileSystem.getInstance().findFileByPath(absolutePath); if (file == null) { file = LocalFileSystem.getInstance().refreshAndFindFileByPath(absolutePath); } if (file == null) { LOG.warn("VirtualFile not found for " + absolutePath); } return file; }
public void testChildrenAccessedButNotCached() throws Exception { File dir = createTempDirectory(false); ManagingFS managingFS = ManagingFS.getInstance(); VirtualFile vFile = LocalFileSystem.getInstance() .refreshAndFindFileByPath(dir.getPath().replace(File.separatorChar, '/')); assertNotNull(vFile); assertFalse(managingFS.areChildrenLoaded(vFile)); assertFalse(managingFS.wereChildrenAccessed(vFile)); File child = new File(dir, "child"); boolean created = child.createNewFile(); assertTrue(created); File subdir = new File(dir, "subdir"); boolean subdirCreated = subdir.mkdir(); assertTrue(subdirCreated); File subChild = new File(subdir, "subdir"); boolean subChildCreated = subChild.createNewFile(); assertTrue(subChildCreated); VirtualFile childVFile = LocalFileSystem.getInstance() .refreshAndFindFileByPath(child.getPath().replace(File.separatorChar, '/')); assertNotNull(childVFile); assertFalse(managingFS.areChildrenLoaded(vFile)); assertTrue(managingFS.wereChildrenAccessed(vFile)); VirtualFile subdirVFile = LocalFileSystem.getInstance() .refreshAndFindFileByPath(subdir.getPath().replace(File.separatorChar, '/')); assertNotNull(subdirVFile); assertFalse(managingFS.areChildrenLoaded(subdirVFile)); assertFalse(managingFS.wereChildrenAccessed(subdirVFile)); assertFalse(managingFS.areChildrenLoaded(vFile)); assertTrue(managingFS.wereChildrenAccessed(vFile)); vFile.getChildren(); assertTrue(managingFS.areChildrenLoaded(vFile)); assertTrue(managingFS.wereChildrenAccessed(vFile)); assertFalse(managingFS.areChildrenLoaded(subdirVFile)); assertFalse(managingFS.wereChildrenAccessed(subdirVFile)); VirtualFile subChildVFile = LocalFileSystem.getInstance() .refreshAndFindFileByPath(subChild.getPath().replace(File.separatorChar, '/')); assertNotNull(subChildVFile); assertTrue(managingFS.areChildrenLoaded(vFile)); assertTrue(managingFS.wereChildrenAccessed(vFile)); assertFalse(managingFS.areChildrenLoaded(subdirVFile)); assertTrue(managingFS.wereChildrenAccessed(subdirVFile)); }
@Nullable public VirtualFile findFileByDartUrl(final @NotNull String url) { if (url.startsWith(DART_PREFIX)) { return findFileInDartSdkLibFolder(myProject, myDartSdk, url); } if (url.startsWith(PACKAGE_PREFIX)) { final String packageRelPath = url.substring(PACKAGE_PREFIX.length()); final int slashIndex = packageRelPath.indexOf('/'); final String packageName = slashIndex > 0 ? packageRelPath.substring(0, slashIndex) : packageRelPath; final String pathRelToPackageDir = slashIndex > 0 ? packageRelPath.substring(slashIndex + 1) : ""; final VirtualFile packageDir = StringUtil.isEmpty(packageName) ? null : myLivePackageNameToDirMap.get(packageName); if (packageDir != null) { return packageDir.findFileByRelativePath(pathRelToPackageDir); } for (final VirtualFile packageRoot : myPackageRoots) { final VirtualFile file = packageRoot.findFileByRelativePath(packageRelPath); if (file != null) { return file; } } final Set<String> packageDirs = myPubListPackageDirsMap.get(packageName); if (packageDirs != null) { for (String packageDirPath : packageDirs) { final VirtualFile file = LocalFileSystem.getInstance() .findFileByPath(packageDirPath + "/" + pathRelToPackageDir); if (file != null) { return file; } } } } if (url.startsWith(FILE_PREFIX)) { final String path = StringUtil.trimLeading(url.substring(FILE_PREFIX.length()), '/'); return LocalFileSystem.getInstance() .findFileByPath(SystemInfo.isWindows ? path : ("/" + path)); } if (ApplicationManager.getApplication().isUnitTestMode() && url.startsWith(TEMP_PREFIX)) { return TempFileSystem.getInstance().findFileByPath(url.substring((TEMP_PREFIX).length())); } return null; }
@NotNull private VirtualFile getOrCreateExtractDirVirtualFile() { File extractDir = new File(myDirectoryTextField.getText()); VirtualFile vFile = LocalFileSystem.getInstance().findFileByIoFile(extractDir); if (vFile == null || !vFile.isValid()) { vFile = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(extractDir); if (vFile == null || !vFile.isValid()) { throw new RuntimeException( "Can't find valid VirtualFile for " + extractDir.getAbsolutePath()); } } return vFile; }
@Override public void run() { Project project = myModule.getProject(); if (GoSdkService.getInstance(project).isGoModule(myModule)) { synchronized (myLastHandledGoPathSourcesRoots) { Collection<VirtualFile> goPathSourcesRoots = GoSdkUtil.getGoPathSources(project, myModule); Set<VirtualFile> excludeRoots = ContainerUtil.newHashSet(ProjectRootManager.getInstance(project).getContentRoots()); ProgressIndicatorProvider.checkCanceled(); if (!myLastHandledGoPathSourcesRoots.equals(goPathSourcesRoots) || !myLastHandledExclusions.equals(excludeRoots)) { Collection<VirtualFile> includeRoots = gatherIncludeRoots(goPathSourcesRoots, excludeRoots); ApplicationManager.getApplication() .invokeLater( () -> { if (!myModule.isDisposed() && GoSdkService.getInstance(project).isGoModule(myModule)) { attachLibraries(includeRoots, excludeRoots); } }); myLastHandledGoPathSourcesRoots.clear(); myLastHandledGoPathSourcesRoots.addAll(goPathSourcesRoots); myLastHandledExclusions.clear(); myLastHandledExclusions.addAll(excludeRoots); List<String> paths = ContainerUtil.map(goPathSourcesRoots, VirtualFile::getPath); myWatchedRequests.clear(); myWatchedRequests.addAll(LocalFileSystem.getInstance().addRootsToWatch(paths, true)); } } } else { synchronized (myLastHandledGoPathSourcesRoots) { LocalFileSystem.getInstance().removeWatchedRoots(myWatchedRequests); myLastHandledGoPathSourcesRoots.clear(); myLastHandledExclusions.clear(); ApplicationManager.getApplication() .invokeLater( () -> { if (!myModule.isDisposed() && GoSdkService.getInstance(project).isGoModule(myModule)) { removeLibraryIfNeeded(); } }); } } }
public void testUnicodeNames() throws Exception { final File dirFile = createTempDirectory(); final String name = "te\u00dft123123123.txt"; final File childFile = new File(dirFile, name); boolean created = childFile.createNewFile(); assert created || childFile.exists() : childFile; final VirtualFile dir = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(dirFile); assertNotNull(dir); final VirtualFile child = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(childFile); assertNotNull(child); assertTrue(childFile.delete()); }
public void scan() { List<VirtualFile> workQueue = myWorkQueue; myWorkQueue = new ArrayList<VirtualFile>(); boolean hasEventsToFire = myFinishRunnable != null || !myEvents.isEmpty(); if (!workQueue.isEmpty()) { LocalFileSystemImpl fs = (LocalFileSystemImpl) LocalFileSystem.getInstance(); fs.markSuspiciousFilesDirty(workQueue); FileWatcher watcher = fs.getFileWatcher(); for (VirtualFile file : workQueue) { NewVirtualFile nvf = (NewVirtualFile) file; if (!myIsRecursive && (!myIsAsync || !watcher.isWatched( nvf))) { // We're unable to definitely refresh synchronously by means of file // watcher. nvf.markDirty(); } RefreshWorker worker = new RefreshWorker(file, myIsRecursive); long t = LOG.isDebugEnabled() ? System.currentTimeMillis() : 0; worker.scan(); List<VFileEvent> events = worker.getEvents(); if (t != 0) { t = System.currentTimeMillis() - t; LOG.debug(file + " scanned in " + t + " ms, events: " + events); } myEvents.addAll(events); if (!events.isEmpty()) hasEventsToFire = true; } } iHaveEventsToFire = hasEventsToFire; }
@Nullable public VirtualFile getPackageDirIfLivePackageOrFromPubListPackageDirs( @NotNull final String packageName, @Nullable final String pathRelToPackageDir) { final VirtualFile dir = myLivePackageNameToDirMap.get(packageName); if (dir != null) return dir; final Set<String> dirPaths = myPubListPackageDirsMap.get(packageName); if (dirPaths != null) { VirtualFile notNullPackageDir = null; for (String dirPath : dirPaths) { final VirtualFile packageDir = ApplicationManager.getApplication().isUnitTestMode() ? TempFileSystem.getInstance().findFileByPath(dirPath) : LocalFileSystem.getInstance().findFileByPath(dirPath); if (notNullPackageDir == null && packageDir != null) { notNullPackageDir = packageDir; } if (packageDir != null && (StringUtil.isEmpty(pathRelToPackageDir) || packageDir.findFileByRelativePath(pathRelToPackageDir) != null)) { return packageDir; } } return notNullPackageDir; // file by pathRelToPackageDir was not found, but not-null // packageDir still may be useful } return null; }
@Override public void setupRootModel(final ModifiableRootModel modifiableRootModel) throws ConfigurationException { String contentEntryPath = getContentEntryPath(); if (StringUtil.isEmpty(contentEntryPath)) { return; } File contentRootDir = new File(contentEntryPath); FileUtilRt.createDirectory(contentRootDir); LocalFileSystem fileSystem = LocalFileSystem.getInstance(); VirtualFile modelContentRootDir = fileSystem.refreshAndFindFileByIoFile(contentRootDir); if (modelContentRootDir == null) { return; } modifiableRootModel.addContentEntry(modelContentRootDir); modifiableRootModel.inheritSdk(); final Project project = modifiableRootModel.getProject(); setupGradleBuildFile(modelContentRootDir); setupGradleSettingsFile(modelContentRootDir, modifiableRootModel); if (myWizardContext.isCreatingNewProject()) { String externalProjectPath = FileUtil.toCanonicalPath(project.getBasePath()); getExternalProjectSettings().setExternalProjectPath(externalProjectPath); AbstractExternalSystemSettings settings = ExternalSystemApiUtil.getSettings(project, GradleConstants.SYSTEM_ID); //noinspection unchecked settings.linkProject(getExternalProjectSettings()); } else { FileDocumentManager.getInstance().saveAllDocuments(); ExternalSystemUtil.refreshProjects(project, GradleConstants.SYSTEM_ID, false); } }
protected void doTest(final PerformAction performAction, final String testName) throws Exception { String path = getTestDataPath() + getTestRoot() + testName; String pathBefore = path + "/before"; final VirtualFile rootDir = PsiTestUtil.createTestProjectStructure( myProject, myModule, pathBefore, myFilesToDelete, false); prepareProject(rootDir); PsiDocumentManager.getInstance(myProject).commitAllDocuments(); String pathAfter = path + "/after"; final VirtualFile rootAfter = LocalFileSystem.getInstance().findFileByPath(pathAfter.replace(File.separatorChar, '/')); performAction.performAction(rootDir, rootAfter); ApplicationManager.getApplication() .runWriteAction( new Runnable() { public void run() { myProject.getComponent(PostprocessReformattingAspect.class).doPostponedFormatting(); } }); FileDocumentManager.getInstance().saveAllDocuments(); if (myDoCompare) { PlatformTestUtil.assertDirectoriesEqual(rootAfter, rootDir); } }
/** call in setUp */ public DuringChangeListManagerUpdateTestScheme(final Project project, final String tmpDirPath) { final MockAbstractVcs vcs = new MockAbstractVcs(project); myChangeProvider = new MockDelayingChangeProvider(); vcs.setChangeProvider(myChangeProvider); final File mockVcsRoot = new File(tmpDirPath, "mock"); mockVcsRoot.mkdir(); final VirtualFile vRoot = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(mockVcsRoot); final ProjectLevelVcsManagerImpl projectLevelVcsManager = (ProjectLevelVcsManagerImpl) ProjectLevelVcsManager.getInstance(project); projectLevelVcsManager.registerVcs(vcs); // projectLevelVcsManager.setDirectoryMapping(mockVcsRoot.getAbsolutePath(), vcs.getName()); final ArrayList<VcsDirectoryMapping> list = new ArrayList<VcsDirectoryMapping>(projectLevelVcsManager.getDirectoryMappings()); list.add(new VcsDirectoryMapping(vRoot.getPath(), vcs.getName())); projectLevelVcsManager.setDirectoryMappings(list); AbstractVcs vcsFound = projectLevelVcsManager.findVcsByName(vcs.getName()); final VirtualFile[] roots = projectLevelVcsManager.getRootsUnderVcs(vcsFound); assert roots.length == 1 : Arrays.asList(roots) + "; " + vcs.getName() + "; " + Arrays.toString(AllVcses.getInstance(project).getAll()); myDirtyScopeManager = VcsDirtyScopeManager.getInstance(project); myClManager = ChangeListManager.getInstance(project); }
@Nullable public static VirtualFile getDirectory(@NotNull final FindModel findModel) { String directoryName = findModel.getDirectoryName(); if (findModel.isProjectScope() || StringUtil.isEmpty(directoryName)) { return null; } String path = directoryName.replace(File.separatorChar, '/'); VirtualFile virtualFile = LocalFileSystem.getInstance().findFileByPath(path); if (virtualFile == null || !virtualFile.isDirectory()) { virtualFile = null; for (LocalFileProvider provider : ((VirtualFileManagerEx) VirtualFileManager.getInstance()).getLocalFileProviders()) { VirtualFile file = provider.findLocalVirtualFileByPath(path); if (file != null && file.isDirectory()) { if (file.getChildren().length > 0) { virtualFile = file; break; } if (virtualFile == null) { virtualFile = file; } } } } return virtualFile; }
public void doCheckout(@NotNull final Project project, @Nullable final Listener listener) { ApplicationManager.getApplication() .runWriteAction( new Runnable() { public void run() { FileDocumentManager.getInstance().saveAllDocuments(); } }); final HgCloneDialog dialog = new HgCloneDialog(project); dialog.show(); if (!dialog.isOK()) { return; } dialog.rememberSettings(); final VirtualFile destinationParent = LocalFileSystem.getInstance().findFileByIoFile(new File(dialog.getParentDirectory())); if (destinationParent == null) { return; } final String targetDir = destinationParent.getPath() + File.separator + dialog.getDirectoryName(); final String sourceRepositoryURL = dialog.getSourceRepositoryURL(); new Task.Backgroundable( project, HgVcsMessages.message("hg4idea.clone.progress", sourceRepositoryURL), true) { @Override public void run(@NotNull ProgressIndicator indicator) { // clone HgCloneCommand clone = new HgCloneCommand(project); clone.setRepositoryURL(sourceRepositoryURL); clone.setDirectory(targetDir); // handle result HgCommandResult myCloneResult = clone.execute(); if (myCloneResult == null) { new HgCommandResultNotifier(project) .notifyError(null, "Clone failed", "Clone failed due to unknown error"); } else if (HgErrorUtil.hasErrorsInCommandExecution(myCloneResult)) { new HgCommandResultNotifier(project) .notifyError( myCloneResult, "Clone failed", "Clone from " + sourceRepositoryURL + " failed."); } else { ApplicationManager.getApplication() .invokeLater( new Runnable() { @Override public void run() { if (listener != null) { listener.directoryCheckedOut( new File(dialog.getParentDirectory(), dialog.getDirectoryName()), HgVcs.getKey()); listener.checkoutCompleted(); } } }); } } }.queue(); }
@WrapInCommand public void testReimportConflictingClasses() throws Exception { configureByFile(BASE_PATH + "/x/Usage.java", BASE_PATH); assertEmpty(highlightErrors()); CodeStyleSettings settings = CodeStyleSettingsManager.getSettings(getProject()).clone(); settings.CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND = 2; CodeStyleSettingsManager.getInstance(getProject()).setTemporarySettings(settings); try { new WriteCommandAction.Simple(getProject()) { @Override protected void run() throws Throwable { JavaCodeStyleManager.getInstance(getProject()).optimizeImports(getFile()); } }.execute().throwException(); } finally { CodeStyleSettingsManager.getInstance(getProject()).dropTemporarySettings(); } @NonNls String fullPath = getTestDataPath() + BASE_PATH + "/x/Usage_afterOptimize.txt"; final VirtualFile vFile = LocalFileSystem.getInstance().findFileByPath(fullPath.replace(File.separatorChar, '/')); String text = LoadTextUtil.loadText(vFile).toString(); assertEquals(text, getFile().getText()); }
public void actionPerformed(final ActionEvent e) { final FileChooserDescriptor descriptor = new FilterFileChooserDescriptor( "Select", "Select a file to import", new FileFilter() { @Override public boolean accept(final File f) { return f.isDirectory() || "xml".equalsIgnoreCase(FileUtilRt.getExtension(f.getAbsolutePath())); } @Override public String getDescription() { return "*.xml"; } }); final Component parent = SwingUtilities.getRoot(_importFile); final VirtualFile toSelect = LocalFileSystem.getInstance().findFileByPath(_importDir); final VirtualFile chosen = FileChooser.chooseFile(descriptor, parent, null, toSelect); if (chosen != null) { _selectedFile = VfsUtilCore.virtualToIoFile(chosen); final String newLocation = _selectedFile.getPath(); _importFile.setText(newLocation); _dialogBuilder.setOkActionEnabled(true); } }
private void waitForFileWatcher(@NotNull Project project) { LocalFileSystem fs = LocalFileSystem.getInstance(); if (!(fs instanceof LocalFileSystemImpl)) return; final FileWatcher watcher = ((LocalFileSystemImpl) fs).getFileWatcher(); if (!watcher.isOperational() || !watcher.isSettingRoots()) return; LOG.info("FW/roots waiting started"); Task.Modal task = new Task.Modal(project, ProjectBundle.message("project.load.progress"), true) { @Override public void run(@NotNull ProgressIndicator indicator) { indicator.setIndeterminate(true); indicator.setText(ProjectBundle.message("project.load.waiting.watcher")); if (indicator instanceof ProgressWindow) { ((ProgressWindow) indicator).setCancelButtonText(CommonBundle.message("button.skip")); } while (watcher.isSettingRoots() && !indicator.isCanceled()) { TimeoutUtil.sleep(10); } LOG.info("FW/roots waiting finished"); } }; myProgressManager.run(task); }
/** @return true if keymap was installed or was successfully installed */ public static boolean installKeyBoardBindings() { LOG.debug("Check for keyboard bindings"); final LocalFileSystem localFileSystem = LocalFileSystem.getInstance(); if (localFileSystem.refreshAndFindFileByPath(KEYMAPS_PATH) == null) { reportError("Failed to install vim keymap. Empty keymaps folder"); return false; } LOG.debug("No vim keyboard installed found. Installing"); try { final byte[] bytes = toByteArray(retrieveSourceKeymapStream()); Files.write(bytes, new File(INSTALLED_VIM_KEYMAP_PATH)); final Document document = StorageUtil.loadDocument(bytes); if (document != null && !ApplicationManager.getApplication().isUnitTestMode()) { // Prompt user to select the parent for the Vim keyboard if (!configureVimParentKeymap(INSTALLED_VIM_KEYMAP_PATH, document, true)) { return false; } } installKeymap(document); } catch (IOException e) { reportError("Source keymap not found", e); return false; } catch (InvalidDataException e) { reportError("Failed to install vim keymap. Vim.xml file is corrupted", e); return false; } catch (Exception e) { reportError("Failed to install vim keymap.\n", e); return false; } return true; }
private void updateWatchedRoots() { Set<String> pathsToRemove = new HashSet<String>(myWatchedOutputs.keySet()); Set<String> toAdd = new HashSet<String>(); for (Artifact artifact : getArtifacts()) { final String path = artifact.getOutputPath(); if (path != null && path.length() > 0) { pathsToRemove.remove(path); if (!myWatchedOutputs.containsKey(path)) { toAdd.add(path); } } } List<LocalFileSystem.WatchRequest> requestsToRemove = new ArrayList<LocalFileSystem.WatchRequest>(); for (String path : pathsToRemove) { final LocalFileSystem.WatchRequest request = myWatchedOutputs.remove(path); ContainerUtil.addIfNotNull(request, requestsToRemove); } Set<LocalFileSystem.WatchRequest> newRequests = LocalFileSystem.getInstance().replaceWatchedRoots(requestsToRemove, toAdd, null); for (LocalFileSystem.WatchRequest request : newRequests) { myWatchedOutputs.put(request.getRootPath(), request); } }
@Test public void testSimpleExternalsStatus() throws Exception { prepareExternal(); final File sourceFile = new File(myWorkingCopyDir.getPath(), "source" + File.separator + "s1.txt"); final File externalFile = new File( myWorkingCopyDir.getPath(), "source" + File.separator + "external" + File.separator + "t12.txt"); final LocalFileSystem lfs = LocalFileSystem.getInstance(); final VirtualFile vf1 = lfs.refreshAndFindFileByIoFile(sourceFile); final VirtualFile vf2 = lfs.refreshAndFindFileByIoFile(externalFile); Assert.assertNotNull(vf1); Assert.assertNotNull(vf2); editFileInCommand(myProject, vf1, "test externals 123" + System.currentTimeMillis()); editFileInCommand(myProject, vf2, "test externals 123" + System.currentTimeMillis()); VcsDirtyScopeManager.getInstance(myProject).markEverythingDirty(); clManager.ensureUpToDate(false); final Change change1 = clManager.getChange(vf1); final Change change2 = clManager.getChange(vf2); Assert.assertNotNull(change1); Assert.assertNotNull(change2); Assert.assertNotNull(change1.getBeforeRevision()); Assert.assertNotNull(change2.getBeforeRevision()); Assert.assertNotNull(change1.getAfterRevision()); Assert.assertNotNull(change2.getAfterRevision()); }
@Override public SourceScope getSourceScope() { final String dirName = myConfiguration.getPersistentData().getDirName(); final VirtualFile file = LocalFileSystem.getInstance().findFileByPath(FileUtil.toSystemIndependentName(dirName)); final GlobalSearchScope globalSearchScope = file == null ? GlobalSearchScope.EMPTY_SCOPE : GlobalSearchScopes.directoryScope(myProject, file, true); return new SourceScope() { @Override public GlobalSearchScope getGlobalSearchScope() { return globalSearchScope; } @Override public Project getProject() { return myProject; } @Override public GlobalSearchScope getLibrariesScope() { final Module module = myConfiguration.getConfigurationModule().getModule(); LOG.assertTrue(module != null); return GlobalSearchScope.moduleWithLibrariesScope(module); } @Override public Module[] getModulesToCompile() { final Collection<Module> validModules = myConfiguration.getValidModules(); return validModules.toArray(new Module[validModules.size()]); } }; }
public void testAddSourceRoot() throws Exception { File dir = createTempDirectory(); final VirtualFile root = LocalFileSystem.getInstance() .refreshAndFindFileByPath(dir.getCanonicalPath().replace(File.separatorChar, '/')); new WriteCommandAction.Simple(getProject()) { @Override protected void run() throws Throwable { PsiTestUtil.addContentRoot(myModule, root); VirtualFile newFile = createChildData(root, "New.java"); setFileText(newFile, "class A{ Exception e;} //todo"); } }.execute().throwException(); PsiDocumentManager.getInstance(myProject).commitAllDocuments(); PsiTodoSearchHelper.SERVICE .getInstance(myProject) .findFilesWithTodoItems(); // to initialize caches PsiTestUtil.addSourceRoot(myModule, root); PsiClass exceptionClass = myJavaFacade.findClass("java.lang.Exception", GlobalSearchScope.allScope(getProject())); assertNotNull(exceptionClass); checkUsages(exceptionClass, new String[] {"1.java", "2.java", "New.java"}); checkTodos(new String[] {"2.java", "New.java"}); }
private static void attachJdkAnnotations(Sdk jdk) { LocalFileSystem lfs = LocalFileSystem.getInstance(); VirtualFile root = null; if (root == null) { // community idea under idea root = lfs.findFileByPath( FileUtil.toSystemIndependentName(PathManager.getHomePath()) + "/java/jdkAnnotations"); } if (root == null) { // idea under idea root = lfs.findFileByPath( FileUtil.toSystemIndependentName(PathManager.getHomePath()) + "/community/java/jdkAnnotations"); } if (root == null) { // build root = VirtualFileManager.getInstance() .findFileByUrl( "jar://" + FileUtil.toSystemIndependentName(PathManager.getHomePath()) + "/lib/jdkAnnotations.jar!/"); } if (root == null) { LOG.error( "jdk annotations not found in: " + FileUtil.toSystemIndependentName(PathManager.getHomePath()) + "/lib/jdkAnnotations.jar!/"); return; } SdkModificator modificator = jdk.getSdkModificator(); modificator.removeRoot(root, AnnotationOrderRootType.getInstance()); modificator.addRoot(root, AnnotationOrderRootType.getInstance()); modificator.commitChanges(); }
@Override protected void setUp() throws Exception { if (ourOutputRoot == null) { ourOutputRoot = FileUtil.createTempDirectory("ExecutionTestCase", null, true); } myModuleOutputDir = new File(ourOutputRoot, PathUtil.getFileName(getTestAppPath())); myChecker = initOutputChecker(); EdtTestUtil.runInEdtAndWait( new ThrowableRunnable<Throwable>() { @Override public void run() throws Throwable { ExecutionTestCase.super.setUp(); } }); if (!myModuleOutputDir.exists()) { VirtualFile vDir = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(ourOutputRoot); assertNotNull(ourOutputRoot.getAbsolutePath(), vDir); vDir .getChildren(); // we need this to load children to VFS to fire VFileCreatedEvent for the // output directory myCompilerTester = new CompilerTester( myProject, Arrays.asList(ModuleManager.getInstance(myProject).getModules())); List<CompilerMessage> messages = myCompilerTester.rebuild(); for (CompilerMessage message : messages) { if (message.getCategory() == CompilerMessageCategory.ERROR) { FileUtil.delete(myModuleOutputDir); fail("Compilation failed: " + message); } } } }
private static Set<VirtualFile> getFilteredResourcesRoots(@NotNull MavenProject mavenProject) { Pair<Long, Set<VirtualFile>> cachedValue = mavenProject.getCachedValue(FILTERED_RESOURCES_ROOTS_KEY); if (cachedValue == null || cachedValue.first != VirtualFileManager.getInstance().getModificationCount()) { Set<VirtualFile> set = null; for (MavenResource resource : ContainerUtil.concat(mavenProject.getResources(), mavenProject.getTestResources())) { if (!resource.isFiltered()) continue; VirtualFile resourceDir = LocalFileSystem.getInstance().findFileByPath(resource.getDirectory()); if (resourceDir == null) continue; if (set == null) { set = new HashSet<VirtualFile>(); } set.add(resourceDir); } if (set == null) { set = Collections.emptySet(); } cachedValue = Pair.create(VirtualFileManager.getInstance().getModificationCount(), set); mavenProject.putCachedValue(FILTERED_RESOURCES_ROOTS_KEY, cachedValue); } return cachedValue.second; }
private void checkProjectRoots() { LocalFileSystem fs = LocalFileSystem.getInstance(); if (!(fs instanceof LocalFileSystemImpl)) return; FileWatcher watcher = ((LocalFileSystemImpl) fs).getFileWatcher(); if (!watcher.isOperational()) return; Collection<String> manualWatchRoots = watcher.getManualWatchRoots(); if (manualWatchRoots.isEmpty()) return; VirtualFile[] roots = ProjectRootManager.getInstance(myProject).getContentRoots(); if (roots.length == 0) return; List<String> nonWatched = new SmartList<String>(); for (VirtualFile root : roots) { if (!(root.getFileSystem() instanceof LocalFileSystem)) continue; String rootPath = root.getPath(); for (String manualWatchRoot : manualWatchRoots) { if (FileUtil.isAncestor(manualWatchRoot, rootPath, false)) { nonWatched.add(rootPath); } } } if (!nonWatched.isEmpty()) { String message = ApplicationBundle.message("watcher.non.watchable.project"); watcher.notifyOnFailure(message, null); LOG.info("unwatched roots: " + nonWatched); LOG.info("manual watches: " + manualWatchRoots); } }
@Override protected void setUp() throws Exception { LOG.debug("================== setting up " + getName() + " =================="); super.setUp(); myFileSystem = LocalFileSystem.getInstance(); assertNotNull(myFileSystem); myWatcher = ((LocalFileSystemImpl) myFileSystem).getFileWatcher(); assertNotNull(myWatcher); assertFalse(myWatcher.isOperational()); myWatcher.startup(myNotifier); assertTrue(myWatcher.isOperational()); myAlarm = new Alarm(Alarm.ThreadToUse.POOLED_THREAD, getProject()); myTimeout = NATIVE_PROCESS_DELAY; myConnection = ApplicationManager.getApplication().getMessageBus().connect(); myConnection.subscribe( VirtualFileManager.VFS_CHANGES, new BulkFileListener.Adapter() { @Override public void after(@NotNull List<? extends VFileEvent> events) { synchronized (myEvents) { myEvents.addAll(events); } } }); ((LocalFileSystemImpl) myFileSystem).cleanupForNextTest(); LOG = FileWatcher.getLog(); LOG.debug("================== setting up " + getName() + " =================="); }
@Override public IFile createFile(String path) { File file = new File(context.absPath(path)); String name = file.getName(); String parentPath = file.getParent(); try { VfsUtil.createDirectories(parentPath); } catch (IOException e) { Flog.error("Create directories error %s", e); context.errorMessage("The Floobits plugin was unable to create directories for file."); return null; } VirtualFile parent = LocalFileSystem.getInstance().findFileByPath(parentPath); if (parent == null) { Flog.error("Virtual file is null? %s", parentPath); return null; } VirtualFile newFile; try { newFile = parent.findOrCreateChildData(context, name); } catch (Throwable e) { Flog.error("Create file error %s", e); context.errorMessage( String.format("The Floobits plugin was unable to create a file: %s.", path)); return null; } return new FileImpl(newFile); }