@NotNull
private static List<VirtualFile> findClasses(File file, boolean isJre) {
List<VirtualFile> result = ContainerUtil.newArrayList();
VirtualFileManager fileManager = VirtualFileManager.getInstance();
String path = file.getPath();
if (JrtFileSystem.isModularJdk(path)) {
String url =
VirtualFileManager.constructUrl(
JrtFileSystem.PROTOCOL,
FileUtil.toSystemIndependentName(path) + JrtFileSystem.SEPARATOR);
for (String module : JrtFileSystem.listModules(path)) {
ContainerUtil.addIfNotNull(result, fileManager.findFileByUrl(url + module));
}
}
for (File root : JavaSdkUtil.getJdkClassesRoots(file, isJre)) {
String url = VfsUtil.getUrlForLibraryRoot(root);
ContainerUtil.addIfNotNull(result, fileManager.findFileByUrl(url));
}
Collections.sort(result, (o1, o2) -> o1.getPath().compareTo(o2.getPath()));
return result;
}
private static String correctRepositoryRule(String input) {
String protocol = VirtualFileManager.extractProtocol(input);
if (protocol == null) {
input = VirtualFileManager.constructUrl(URLUtil.HTTP_PROTOCOL, input);
}
return input;
}
@Nullable
public static String getAnnotationProcessorsGenerationPath(Module module) {
final CompilerConfiguration config = CompilerConfiguration.getInstance(module.getProject());
final String sourceDirName = config.getGeneratedSourceDirName(module);
if (sourceDirName != null && sourceDirName.length() > 0) {
final String[] roots = ModuleRootManager.getInstance(module).getContentRootUrls();
if (roots.length == 0) {
return null;
}
if (roots.length > 1) {
Arrays.sort(roots, URLS_COMPARATOR);
}
return VirtualFileManager.extractPath(roots[0]) + "/" + sourceDirName;
}
final CompilerProjectExtension extension =
CompilerProjectExtension.getInstance(module.getProject());
if (extension == null) {
return null;
}
final String url = extension.getCompilerOutputUrl();
if (url == null) {
return null;
}
return VirtualFileManager.extractPath(url)
+ "/"
+ DEFAULT_GENERATED_DIR_NAME
+ "/"
+ module.getName().toLowerCase();
}
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;
}
@NotNull
private VirtualFilePointer create(
@Nullable("null means the pointer will be created from the (not null) url") VirtualFile file,
@Nullable("null means url has to be computed from the (not-null) file path") String url,
@NotNull Disposable parentDisposable,
@Nullable VirtualFilePointerListener listener) {
VirtualFileSystem fileSystem;
String protocol;
String path;
if (file == null) {
int protocolEnd = url.indexOf(URLUtil.SCHEME_SEPARATOR);
if (protocolEnd == -1) {
protocol = null;
fileSystem = null;
} else {
protocol = url.substring(0, protocolEnd);
fileSystem = myVirtualFileManager.getFileSystem(protocol);
}
path = url.substring(protocolEnd + URLUtil.SCHEME_SEPARATOR.length());
} else {
fileSystem = file.getFileSystem();
protocol = fileSystem.getProtocol();
path = file.getPath();
url = VirtualFileManager.constructUrl(protocol, path);
}
if (fileSystem == TEMP_FILE_SYSTEM) {
// for tests, recreate always
VirtualFile found = file == null ? VirtualFileManager.getInstance().findFileByUrl(url) : file;
return new IdentityVirtualFilePointer(found, url);
}
boolean isJar = fileSystem == JAR_FILE_SYSTEM;
if (fileSystem != LOCAL_FILE_SYSTEM && !isJar) {
// we are unable to track alien file systems for now
VirtualFile found =
fileSystem == null
? null
: file != null ? file : VirtualFileManager.getInstance().findFileByUrl(url);
// if file is null, this pointer will never be alive
return getOrCreateIdentity(url, found);
}
if (file == null) {
String cleanPath = cleanupPath(path, isJar);
// if newly created path is the same as substringed from url one then the url did not change,
// we can reuse it
//noinspection StringEquality
if (cleanPath != path) {
url = VirtualFileManager.constructUrl(protocol, cleanPath);
path = cleanPath;
}
}
// else url has come from VirtualFile.getPath() and is good enough
VirtualFilePointerImpl pointer =
getOrCreate(parentDisposable, listener, path, Pair.create(file, url));
DelegatingDisposable.registerDisposable(parentDisposable, pointer);
return pointer;
}
private String dubImportPath(String rootPath) {
String pathUrl = VirtualFileManager.constructUrl(LocalFileSystem.PROTOCOL, rootPath);
VirtualFile file = VirtualFileManager.getInstance().findFileByUrl(pathUrl);
if (file == null) {
return null;
}
final List<String> sourcesDir = new ArrayList<>();
VfsUtilCore.visitChildrenRecursively(
file,
new VirtualFileVisitor() {
@Override
public boolean visitFile(@NotNull VirtualFile file) {
if (file.isDirectory()) {
if (file.getName().equals("source")) {
sourcesDir.add("source");
}
if (file.getName().equals("src")) {
sourcesDir.add("src");
}
}
return true;
}
});
return sourcesDir.isEmpty() ? null : rootPath + File.separator + sourcesDir.get(0);
}
@NotNull
private VirtualFilePointer create(
@Nullable VirtualFile file,
@NotNull String url,
@NotNull final Disposable parentDisposable,
@Nullable VirtualFilePointerListener listener) {
String protocol;
VirtualFileSystem fileSystem;
if (file == null) {
protocol = VirtualFileManager.extractProtocol(url);
fileSystem = myVirtualFileManager.getFileSystem(protocol);
} else {
protocol = null;
fileSystem = file.getFileSystem();
}
if (fileSystem == TempFileSystem.getInstance()) {
// for tests, recreate always since
VirtualFile found =
fileSystem == null
? null
: file != null ? file : VirtualFileManager.getInstance().findFileByUrl(url);
return new IdentityVirtualFilePointer(found, url);
}
if (fileSystem != LocalFileSystem.getInstance() && fileSystem != JarFileSystem.getInstance()) {
// we are unable to track alien file systems for now
VirtualFile found =
fileSystem == null
? null
: file != null ? file : VirtualFileManager.getInstance().findFileByUrl(url);
// if file is null, this pointer will never be alive
return getOrCreateIdentity(url, found);
}
String path;
if (file == null) {
path = VirtualFileManager.extractPath(url);
path = cleanupPath(path, protocol);
url = VirtualFileManager.constructUrl(protocol, path);
} else {
path = file.getPath();
// url has come from VirtualFile.getUrl() and is good enough
}
VirtualFilePointerImpl pointer = getOrCreate(file, url, parentDisposable, listener, path);
int newCount = pointer.incrementUsageCount();
if (newCount == 1) {
Disposer.register(parentDisposable, pointer);
} else {
// already registered
register(parentDisposable, pointer);
}
return pointer;
}
private void disposeListeners() {
FileStatusManager.getInstance(myProject).removeFileStatusListener(myFileStatusListener);
VirtualFileManager.getInstance().removeVirtualFileListener(myFileListener);
VirtualFileManager.getInstance().removeVirtualFileManagerListener(myVirtualFileManagerListener);
myProject
.getComponent(ProjectLevelVcsManager.class)
.removeVcsListener(myDirectoryMappingListener);
ChangeListManager.getInstance(myProject).removeChangeListListener(myChangeListListener);
myMessageBusConnection.disconnect();
}
@Nullable
private static VirtualFile findFileByUrl(@Nullable String url) {
if (url == null) {
return null;
}
VirtualFile file = VirtualFileManager.getInstance().findFileByUrl(url);
if (file == null) {
// groovy stubs may be placed in completely random directories which aren't refreshed
// automatically
return VirtualFileManager.getInstance().refreshAndFindFileByUrl(url);
}
return file;
}
@Nullable
private static VirtualFile getHelpFile(final PsiElement element) {
final XmlTag xmlTag = PsiTreeUtil.getParentOfType(element, XmlTag.class);
if (xmlTag == null) {
return null;
}
final AntDomElement antElement = AntSupport.getAntDomElement(xmlTag);
if (antElement == null) {
return null;
}
final AntDomProject antProject = antElement.getAntProject();
if (antProject == null) {
return null;
}
final AntInstallation installation = antProject.getAntInstallation();
if (installation == null) {
return null; // not configured properly and bundled installation missing
}
final String antHomeDir = AntInstallation.HOME_DIR.get(installation.getProperties());
if (antHomeDir == null) {
return null;
}
@NonNls String path = antHomeDir + "/docs/manual";
String url;
if (new File(path).exists()) {
url =
VirtualFileManager.constructUrl(
LocalFileSystem.PROTOCOL, FileUtil.toSystemIndependentName(path));
} else {
path = antHomeDir + "/docs.zip";
if (new File(path).exists()) {
url =
VirtualFileManager.constructUrl(
JarFileSystem.PROTOCOL,
FileUtil.toSystemIndependentName(path)
+ JarFileSystem.JAR_SEPARATOR
+ "docs/manual");
} else {
return null;
}
}
final VirtualFile documentationRoot = VirtualFileManager.getInstance().findFileByUrl(url);
if (documentationRoot == null) {
return null;
}
return getHelpFile(antElement, documentationRoot);
}
public void testFindRoot() throws IOException {
VirtualFile root = LocalFileSystem.getInstance().findFileByPath("wrong_path");
assertNull(root);
VirtualFile root2;
if (SystemInfo.isWindows) {
root = LocalFileSystem.getInstance().findFileByPath("\\\\unit-133");
assertNotNull(root);
root2 = LocalFileSystem.getInstance().findFileByPath("//UNIT-133");
assertNotNull(root2);
assertEquals(String.valueOf(root2), root, root2);
RefreshQueue.getInstance().processSingleEvent(new VFileDeleteEvent(this, root, false));
root = LocalFileSystem.getInstance().findFileByIoFile(new File("\\\\unit-133"));
assertNotNull(root);
RefreshQueue.getInstance().processSingleEvent(new VFileDeleteEvent(this, root, false));
if (new File("c:").exists()) {
root = LocalFileSystem.getInstance().findFileByPath("c:");
assertNotNull(root);
assertEquals("C:/", root.getPath());
root2 = LocalFileSystem.getInstance().findFileByPath("C:\\");
assertEquals(String.valueOf(root2), root, root2);
}
} else if (SystemInfo.isUnix) {
root = LocalFileSystem.getInstance().findFileByPath("/");
assertNotNull(root);
assertEquals(root.getPath(), "/");
}
root = LocalFileSystem.getInstance().findFileByPath("");
assertNotNull(root);
File jarFile = IoTestUtil.createTestJar();
root = VirtualFileManager.getInstance().findFileByUrl("jar://" + jarFile.getPath() + "!/");
assertNotNull(root);
root2 =
VirtualFileManager.getInstance()
.findFileByUrl("jar://" + jarFile.getPath().replace(File.separator, "//") + "!/");
assertEquals(String.valueOf(root2), root, root2);
if (!SystemInfo.isFileSystemCaseSensitive) {
root2 =
VirtualFileManager.getInstance()
.findFileByUrl("jar://" + jarFile.getPath().toUpperCase(Locale.US) + "!/");
assertEquals(String.valueOf(root2), root, root2);
}
}
public Location getLocation(String url) {
String protocol = VirtualFileManager.extractProtocol(url);
String path = VirtualFileManager.extractPath(url);
if (protocol != null) {
List<Location> locations =
JavaTestLocator.INSTANCE.getLocation(
protocol, path, myProject, GlobalSearchScope.allScope(myProject));
if (!locations.isEmpty()) {
return locations.get(0);
}
}
return null;
}
private void updateTree() {
if (myFileSystemTree != null) {
Disposer.dispose(myFileSystemTree);
myFileSystemTree = null;
}
myFileSystemTree =
new FileSystemTreeImpl(
null, new FileChooserDescriptor(true, true, true, true, true, false));
AbstractTreeUi ui = myFileSystemTree.getTreeBuilder().getUi();
String path = myModelRoot.getPath() == null ? "" : myModelRoot.getPath();
VirtualFile virtualFile =
VirtualFileManager.getInstance()
.findFileByUrl(VirtualFileManager.constructUrl("file", path));
if (myModelRoot.getModule() != null && (virtualFile == null || path.isEmpty())) {
if (myModelRoot.getModule() instanceof AbstractModule) {
virtualFile =
VirtualFileManager.getInstance()
.findFileByUrl(
VirtualFileManager.constructUrl(
"file",
((AbstractModule) myModelRoot.getModule())
.getModuleSourceDir()
.getPath()));
}
}
if (virtualFile != null) myFileSystemTree.select(virtualFile, null);
myFileSystemTree.addListener(
new Listener() {
@Override
public void selectionChanged(List<VirtualFile> selection) {
if (selection.size() > 0) {
myModelRoot.setPath(FileUtil.getCanonicalPath(selection.get(0).getPath()));
myEventDispatcher.getMulticaster().fireDataChanged();
}
}
},
SModelRootEntry.this);
Disposer.register(SModelRootEntry.this, myFileSystemTree);
myTreePanel.removeAll();
myTreePanel.add(ui.getTree(), BorderLayout.CENTER);
ui.scrollSelectionToVisible(null, true);
}
/**
* The same as {@link #getModuleOutputDirectory} but returns String. The method still returns a
* non-null value if the output path is specified in Settings but does not exist on disk.
*/
@Nullable
public static String getModuleOutputPath(final Module module, boolean forTestClasses) {
final String outPathUrl;
final Application application = ApplicationManager.getApplication();
final CompilerModuleExtension extension = CompilerModuleExtension.getInstance(module);
if (forTestClasses) {
if (application.isDispatchThread()) {
final String url = extension.getCompilerOutputUrlForTests();
outPathUrl = url != null ? url : extension.getCompilerOutputUrl();
} else {
outPathUrl =
application.runReadAction(
new Computable<String>() {
public String compute() {
final String url = extension.getCompilerOutputUrlForTests();
return url != null ? url : extension.getCompilerOutputUrl();
}
});
}
} else { // for ordinary classes
if (application.isDispatchThread()) {
outPathUrl = extension.getCompilerOutputUrl();
} else {
outPathUrl =
application.runReadAction(
new Computable<String>() {
public String compute() {
return extension.getCompilerOutputUrl();
}
});
}
}
return outPathUrl != null ? VirtualFileManager.extractPath(outPathUrl) : null;
}
@Nullable
@Override
public RefEntity getReference(final String type, final String fqName) {
for (RefManagerExtension extension : myExtensions.values()) {
final RefEntity refEntity = extension.getReference(type, fqName);
if (refEntity != null) return refEntity;
}
if (SmartRefElementPointer.FILE.equals(type)) {
return RefFileImpl.fileFromExternalName(this, fqName);
}
if (SmartRefElementPointer.MODULE.equals(type)) {
return RefModuleImpl.moduleFromName(this, fqName);
}
if (SmartRefElementPointer.PROJECT.equals(type)) {
return getRefProject();
}
if (SmartRefElementPointer.DIR.equals(type)) {
String url =
VfsUtilCore.pathToUrl(PathMacroManager.getInstance(getProject()).expandPath(fqName));
VirtualFile vFile = VirtualFileManager.getInstance().findFileByUrl(url);
if (vFile != null) {
final PsiDirectory dir = PsiManager.getInstance(getProject()).findDirectory(vFile);
return getReference(dir);
}
}
return null;
}
private static void updateUrl(
Library.ModifiableModel library,
OrderRootType type,
MavenArtifact artifact,
MavenExtraArtifactType artifactType,
MavenProject project,
boolean clearAll) {
String classifier = null;
String extension = null;
if (artifactType != null) {
Pair<String, String> result = project.getClassifierAndExtension(artifact, artifactType);
classifier = result.first;
extension = result.second;
}
String newPath = artifact.getPathForExtraArtifact(classifier, extension);
String newUrl =
VirtualFileManager.constructUrl(JarFileSystem.PROTOCOL, newPath)
+ JarFileSystem.JAR_SEPARATOR;
for (String url : library.getUrls(type)) {
if (newUrl.equals(url)) return;
if (clearAll || isRepositoryUrl(artifact, url, classifier, extension)) {
library.removeRoot(url, type);
}
}
library.addRoot(newUrl, type);
}
public synchronized void runPostStartupActivities() {
final Application app = ApplicationManager.getApplication();
app.assertIsDispatchThread();
if (myPostStartupActivitiesPassed) return;
runActivities(myDumbAwarePostStartupActivities);
DumbService.getInstance(myProject)
.runWhenSmart(
new Runnable() {
public void run() {
synchronized (StartupManagerImpl.this) {
app.assertIsDispatchThread();
if (myProject.isDisposed()) return;
runActivities(
myDumbAwarePostStartupActivities); // they can register activities while in
// the dumb mode
runActivities(myNotDumbAwarePostStartupActivities);
myPostStartupActivitiesPassed = true;
}
}
});
if (!app.isUnitTestMode()) {
VirtualFileManager.getInstance().refresh(!app.isHeadlessEnvironment());
}
}
public ExternalAnnotationsManagerImpl(
@NotNull final Project project, final PsiManager psiManager) {
super(psiManager);
myBus = project.getMessageBus();
final MessageBusConnection connection = myBus.connect(project);
connection.subscribe(
ProjectTopics.PROJECT_ROOTS,
new ModuleRootAdapter() {
@Override
public void rootsChanged(ModuleRootEvent event) {
dropCache();
}
});
final MyVirtualFileListener fileListener = new MyVirtualFileListener();
VirtualFileManager.getInstance().addVirtualFileListener(fileListener);
Disposer.register(
myPsiManager.getProject(),
new Disposable() {
@Override
public void dispose() {
VirtualFileManager.getInstance().removeVirtualFileListener(fileListener);
}
});
}
@Override
public void deactivate() {
FrameStateManager.getInstance().removeListener(myFrameStateListener);
final ProjectLevelVcsManager vcsManager = ProjectLevelVcsManager.getInstance(myProject);
if (myVcsListener != null) {
vcsManager.removeVcsListener(myVcsListener);
}
if (myEntriesFileListener != null) {
VirtualFileManager.getInstance().removeVirtualFileListener(myEntriesFileListener);
}
SvnApplicationSettings.getInstance().svnDeactivated();
if (myCommittedChangesProvider != null) {
myCommittedChangesProvider.deactivate();
}
if (myChangeListListener != null && !myProject.isDefault()) {
ChangeListManager.getInstance(myProject).removeChangeListListener(myChangeListListener);
}
vcsManager.removeVcsListener(myRootsToWorkingCopies);
myRootsToWorkingCopies.clear();
myAuthNotifier.stop();
myAuthNotifier.clear();
mySvnBranchPointsCalculator.deactivate();
mySvnBranchPointsCalculator = null;
myWorkingCopiesContent.deactivate();
myLoadedBranchesStorage.deactivate();
myPool.dispose();
myPool = null;
}
public Object[] createPath(final Project project) {
final VirtualFile file = VirtualFileManager.getInstance().findFileByUrl(url);
if (file == null || !file.isValid()) {
return null;
}
return new Object[] {PsiManager.getInstance(project).findFile(file)};
}
@Override
public void moduleAdded() {
if (!myModuleInitialized) {
myConnection.subscribe(
ProjectTopics.PROJECT_ROOTS,
new ModuleRootAdapter() {
@Override
public void rootsChanged(ModuleRootEvent event) {
scheduleUpdate();
}
});
myConnection.subscribe(GoLibrariesService.LIBRARIES_TOPIC, newRootUrls -> scheduleUpdate());
Project project = myModule.getProject();
StartupManager.getInstance(project)
.runWhenProjectIsInitialized(
() -> {
if (!project.isDisposed() && !myModule.isDisposed()) {
for (PsiFileSystemItem vendor :
FilenameIndex.getFilesByName(
project, GoConstants.VENDOR, GoUtil.moduleScope(myModule), true)) {
if (vendor.isDirectory()) {
showVendoringNotification();
break;
}
}
}
});
VirtualFileManager.getInstance().addVirtualFileListener(myFilesListener);
}
scheduleUpdate(0);
myModuleInitialized = true;
}
@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;
}
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();
}
public VirtualFile getOutputDir(IceComponent c) {
VirtualFile file = outputDir.get(c);
if (outputDirPath.get(c) != null && file == null) {
file = VirtualFileManager.getInstance().findFileByUrl(outputDirPath.get(c));
outputDir.put(c, file);
}
return file;
}
public static VirtualFile findVirtualFile(String systemId) {
try {
return VfsUtil.findFileByURL(new URL(systemId));
} catch (Exception e) {
LOG.warn("Failed to build file from uri <" + systemId + ">", e);
return VirtualFileManager.getInstance().findFileByUrl(VfsUtilCore.fixURLforIDEA(systemId));
}
}
public CachedValueProvider.Result<VirtualFile[]> compute(PsiFile psiFile) {
VirtualFile[] value = computeFiles(psiFile, myRuntimeOnly);
// todo: we need "url modification tracker" for VirtualFile
Object[] deps = new Object[value.length + 2];
deps[deps.length - 2] = psiFile;
deps[deps.length - 1] = VirtualFileManager.getInstance();
return CachedValueProvider.Result.create(value, deps);
}
public TableItem(String url) {
myUrl = url;
final VirtualFile file = VirtualFileManager.getInstance().findFileByUrl(url);
if (file != null) {
myCellAppearance = CellAppearanceUtils.forVirtualFile(file);
} else {
myCellAppearance = SimpleTextCellAppearance.invalid(url, CellAppearanceUtils.INVALID_ICON);
}
}
public ProjectRootManagerComponent(Project project, StartupManager startupManager) {
super(project);
myConnection = project.getMessageBus().connect(project);
myConnection.subscribe(
FileTypeManager.TOPIC,
new FileTypeListener() {
@Override
public void beforeFileTypesChanged(@NotNull FileTypeEvent event) {
beforeRootsChange(true);
}
@Override
public void fileTypesChanged(@NotNull FileTypeEvent event) {
rootsChanged(true);
}
});
VirtualFileManager.getInstance()
.addVirtualFileManagerListener(
new VirtualFileManagerAdapter() {
@Override
public void afterRefreshFinish(boolean asynchronous) {
doUpdateOnRefresh();
}
},
project);
startupManager.registerStartupActivity(
new Runnable() {
@Override
public void run() {
myStartupActivityPerformed = true;
}
});
myHandler =
new BatchUpdateListener() {
@Override
public void onBatchUpdateStarted() {
myRootsChanged.levelUp();
myFileTypesChanged.levelUp();
}
@Override
public void onBatchUpdateFinished() {
myRootsChanged.levelDown();
myFileTypesChanged.levelDown();
}
};
myConnection.subscribe(VirtualFilePointerListener.TOPIC, new MyVirtualFilePointerListener());
myDoLogCachesUpdate =
ApplicationManager.getApplication().isInternal()
&& !ApplicationManager.getApplication().isUnitTestMode();
}
public void testCreationOfExcludedDirWithFilesDuringRefreshShouldNotThrowException()
throws Exception {
// there was a problem with the DirectoryIndex - the files that were created during the refresh
// were not correctly excluded, thereby causing the LocalHistory to fail during addition of
// files under the excluded dir.
File targetDir = createTargetDir();
FileUtil.copyDir(targetDir, new File(myRoot.getPath(), "target"));
VirtualFileManager.getInstance().syncRefresh();
String classesPath = myRoot.getPath() + "/target/classes";
addExcludedDir(classesPath);
final VirtualFile classesDir = LocalFileSystem.getInstance().findFileByPath(classesPath);
assertNotNull(classesDir);
delete(classesDir.getParent());
FileUtil.copyDir(targetDir, new File(myRoot.getPath(), "target"));
VirtualFileManager.getInstance().syncRefresh(); // shouldn't throw
}
@Override
public void disposeComponent() {
Disposer.dispose(myConnection);
Disposer.dispose(myAlarm);
VirtualFileManager.getInstance().removeVirtualFileListener(myFilesListener);
myLastHandledGoPathSourcesRoots.clear();
myLastHandledExclusions.clear();
LocalFileSystem.getInstance().removeWatchedRoots(myWatchedRequests);
myWatchedRequests.clear();
}