public static List<String> getTypeNames() {
List<String> names = new ArrayList<>();
for (ModuleType type : ModuleType.values()) {
names.add(type.toString());
}
return names;
}
/**
* @deprecated use ModuleManager#getModuleDependentModules(com.intellij.openapi.module.Module)
* instead
*/
@Nullable
public static Module getParentModuleOfType(ModuleType expectedModuleType, Module module) {
if (module == null) return null;
if (expectedModuleType.equals(ModuleType.get(module))) return module;
final List<Module> parents = getParentModulesOfType(expectedModuleType, module);
return parents.isEmpty() ? null : parents.get(0);
}
/**
* @deprecated use ModuleManager#getModuleDependentModules(com.intellij.openapi.module.Module)
* instead
*/
@NotNull
public static List<Module> getParentModulesOfType(ModuleType expectedModuleType, Module module) {
final List<Module> parents =
ModuleManager.getInstance(module.getProject()).getModuleDependentModules(module);
ArrayList<Module> modules = new ArrayList<Module>();
for (Module parent : parents) {
if (expectedModuleType.equals(ModuleType.get(parent))) {
modules.add(parent);
}
}
return modules;
}
@NotNull
public static ModuleType getModuleType(@NotNull ErlangFile file) {
ModuleType type = ModuleType.REGULAR;
for (ErlangBehaviour behaviour : file.getBehaviours()) {
type = ModuleType.getType(behaviour.getName());
if (type != ModuleType.REGULAR) break;
}
return type;
}
public static boolean isSupportedRootType(
Project project, JpsModuleSourceRootType sourceRootType) {
Module[] modules = ModuleManager.getInstance(project).getModules();
for (Module module : modules) {
if (ModuleType.get(module).isSupportedRootType(sourceRootType)) {
return true;
}
}
return modules.length == 0;
}
@Nullable
@Override
public CachedValueProvider.Result<MultiMap<ModuleType<?>, Module>> compute(
Project param) {
MultiMap<ModuleType<?>, Module> map = new MultiMap<ModuleType<?>, Module>();
for (Module module : ModuleManager.getInstance(param).getModules()) {
map.putValue(ModuleType.get(module), module);
}
return CachedValueProvider.Result.createSingleDependency(
map, ProjectRootManager.getInstance(param));
}
@NotNull
public static ModuleType getType(@NotNull String behaviourName) {
for (ModuleType type : ModuleType.values())
if (StringUtil.equals(type.behaviourName, behaviourName)) return type;
return REGULAR;
}
@NotNull
@Override
public List<SearchScope> getPredefinedScopes(
@NotNull final Project project,
@Nullable final DataContext dataContext,
boolean suggestSearchInLibs,
boolean prevSearchFiles,
boolean currentSelection,
boolean usageView,
boolean showEmptyScopes) {
Collection<SearchScope> result = ContainerUtil.newLinkedHashSet();
result.add(GlobalSearchScope.projectScope(project));
if (suggestSearchInLibs) {
result.add(GlobalSearchScope.allScope(project));
}
if (ModuleUtil.isSupportedRootType(project, JavaSourceRootType.TEST_SOURCE)) {
result.add(GlobalSearchScopesCore.projectProductionScope(project));
result.add(GlobalSearchScopesCore.projectTestScope(project));
}
final GlobalSearchScope openFilesScope = GlobalSearchScopes.openFilesScope(project);
if (openFilesScope != GlobalSearchScope.EMPTY_SCOPE) {
result.add(openFilesScope);
} else if (showEmptyScopes) {
result.add(
new LocalSearchScope(PsiElement.EMPTY_ARRAY, IdeBundle.message("scope.open.files")));
}
final Editor selectedTextEditor =
ApplicationManager.getApplication().isDispatchThread()
? FileEditorManager.getInstance(project).getSelectedTextEditor()
: null;
final PsiFile psiFile =
(selectedTextEditor != null)
? PsiDocumentManager.getInstance(project).getPsiFile(selectedTextEditor.getDocument())
: null;
PsiFile currentFile = psiFile;
if (dataContext != null) {
PsiElement dataContextElement = CommonDataKeys.PSI_FILE.getData(dataContext);
if (dataContextElement == null) {
dataContextElement = CommonDataKeys.PSI_ELEMENT.getData(dataContext);
}
if (dataContextElement == null && psiFile != null) {
dataContextElement = psiFile;
}
if (dataContextElement != null) {
if (!PlatformUtils.isCidr()) { // TODO: have an API to disable module scopes.
Module module = ModuleUtilCore.findModuleForPsiElement(dataContextElement);
if (module == null) {
module = LangDataKeys.MODULE.getData(dataContext);
}
if (module != null && !(ModuleType.get(module) instanceof InternalModuleType)) {
result.add(module.getModuleScope());
}
}
if (currentFile == null) {
currentFile = dataContextElement.getContainingFile();
}
}
}
if (currentFile != null || showEmptyScopes) {
PsiElement[] scope =
currentFile != null ? new PsiElement[] {currentFile} : PsiElement.EMPTY_ARRAY;
result.add(new LocalSearchScope(scope, IdeBundle.message("scope.current.file")));
}
if (currentSelection && selectedTextEditor != null && psiFile != null) {
SelectionModel selectionModel = selectedTextEditor.getSelectionModel();
if (selectionModel.hasSelection()) {
int start = selectionModel.getSelectionStart();
final PsiElement startElement = psiFile.findElementAt(start);
if (startElement != null) {
int end = selectionModel.getSelectionEnd();
final PsiElement endElement = psiFile.findElementAt(end);
if (endElement != null) {
final PsiElement parent = PsiTreeUtil.findCommonParent(startElement, endElement);
if (parent != null) {
final List<PsiElement> elements = new ArrayList<PsiElement>();
final PsiElement[] children = parent.getChildren();
TextRange selection = new TextRange(start, end);
for (PsiElement child : children) {
if (!(child instanceof PsiWhiteSpace)
&& child.getContainingFile() != null
&& selection.contains(child.getTextOffset())) {
elements.add(child);
}
}
if (!elements.isEmpty()) {
SearchScope local =
new LocalSearchScope(
PsiUtilCore.toPsiElementArray(elements),
IdeBundle.message("scope.selection"));
result.add(local);
}
}
}
}
}
}
if (usageView) {
addHierarchyScope(project, result);
UsageView selectedUsageView = UsageViewManager.getInstance(project).getSelectedUsageView();
if (selectedUsageView != null && !selectedUsageView.isSearchInProgress()) {
final Set<Usage> usages = ContainerUtil.newTroveSet(selectedUsageView.getUsages());
usages.removeAll(selectedUsageView.getExcludedUsages());
final List<PsiElement> results = new ArrayList<PsiElement>(usages.size());
if (prevSearchFiles) {
final Set<VirtualFile> files = collectFiles(usages, true);
if (!files.isEmpty()) {
GlobalSearchScope prev =
new GlobalSearchScope(project) {
private Set<VirtualFile> myFiles = null;
@NotNull
@Override
public String getDisplayName() {
return IdeBundle.message("scope.files.in.previous.search.result");
}
@Override
public synchronized boolean contains(@NotNull VirtualFile file) {
if (myFiles == null) {
myFiles = collectFiles(usages, false);
}
return myFiles.contains(file);
}
@Override
public int compare(@NotNull VirtualFile file1, @NotNull VirtualFile file2) {
return 0;
}
@Override
public boolean isSearchInModuleContent(@NotNull Module aModule) {
return true;
}
@Override
public boolean isSearchInLibraries() {
return true;
}
};
result.add(prev);
}
} else {
for (Usage usage : usages) {
if (usage instanceof PsiElementUsage) {
final PsiElement element = ((PsiElementUsage) usage).getElement();
if (element != null && element.isValid() && element.getContainingFile() != null) {
results.add(element);
}
}
}
if (!results.isEmpty()) {
result.add(
new LocalSearchScope(
PsiUtilCore.toPsiElementArray(results),
IdeBundle.message("scope.previous.search.results")));
}
}
}
}
final FavoritesManager favoritesManager = FavoritesManager.getInstance(project);
if (favoritesManager != null) {
for (final String favorite : favoritesManager.getAvailableFavoritesListNames()) {
final Collection<TreeItem<Pair<AbstractUrl, String>>> rootUrls =
favoritesManager.getFavoritesListRootUrls(favorite);
if (rootUrls.isEmpty()) continue; // ignore unused root
result.add(
new GlobalSearchScope(project) {
@NotNull
@Override
public String getDisplayName() {
return "Favorite \'" + favorite + "\'";
}
@Override
public boolean contains(@NotNull final VirtualFile file) {
return ApplicationManager.getApplication()
.runReadAction(
(Computable<Boolean>) () -> favoritesManager.contains(favorite, file));
}
@Override
public int compare(
@NotNull final VirtualFile file1, @NotNull final VirtualFile file2) {
return 0;
}
@Override
public boolean isSearchInModuleContent(@NotNull final Module aModule) {
return true;
}
@Override
public boolean isSearchInLibraries() {
return true;
}
});
}
}
ContainerUtil.addIfNotNull(result, getSelectedFilesScope(project, dataContext));
return ContainerUtil.newArrayList(result);
}
/** Set the module to Veritomyx's PeakInvestigator™ */
public void setValueToVeritomxy() {
for (int i = 0; i < modulesWithParams.length; i++) {
ModuleType mod = modulesWithParams[i].getModule();
if (mod.getClass() == PeakInvestigatorDetector.class) value = modulesWithParams[i];
}
}
