@TestOnly private static VirtualFile[] getAllRoots(@NotNull Project project) { insideGettingRoots = true; final Set<VirtualFile> roots = new THashSet<VirtualFile>(); final OrderEnumerator enumerator = ProjectRootManager.getInstance(project).orderEntries(); ContainerUtil.addAll(roots, enumerator.getClassesRoots()); ContainerUtil.addAll(roots, enumerator.getSourceRoots()); insideGettingRoots = false; return VfsUtilCore.toVirtualFileArray(roots); }
@NotNull private Map<VirtualFile, OrderEntry[]> getOrderEntries() { Map<VirtualFile, OrderEntry[]> result = myOrderEntries; if (result != null) return result; MultiMap<VirtualFile, OrderEntry> libClassRootEntries = MultiMap.createSmart(); MultiMap<VirtualFile, OrderEntry> libSourceRootEntries = MultiMap.createSmart(); MultiMap<VirtualFile, OrderEntry> depEntries = MultiMap.createSmart(); for (final Module module : ModuleManager.getInstance(myProject).getModules()) { final ModuleRootManager moduleRootManager = ModuleRootManager.getInstance(module); for (OrderEntry orderEntry : moduleRootManager.getOrderEntries()) { if (orderEntry instanceof ModuleOrderEntry) { final Module depModule = ((ModuleOrderEntry) orderEntry).getModule(); if (depModule != null) { VirtualFile[] importedClassRoots = OrderEnumerator.orderEntries(depModule) .exportedOnly() .recursively() .classes() .usingCache() .getRoots(); for (VirtualFile importedClassRoot : importedClassRoots) { depEntries.putValue(importedClassRoot, orderEntry); } } for (VirtualFile sourceRoot : orderEntry.getFiles(OrderRootType.SOURCES)) { depEntries.putValue(sourceRoot, orderEntry); } } else if (orderEntry instanceof LibraryOrSdkOrderEntry) { final LibraryOrSdkOrderEntry entry = (LibraryOrSdkOrderEntry) orderEntry; for (final VirtualFile sourceRoot : entry.getRootFiles(OrderRootType.SOURCES)) { libSourceRootEntries.putValue(sourceRoot, orderEntry); } for (final VirtualFile classRoot : entry.getRootFiles(OrderRootType.CLASSES)) { libClassRootEntries.putValue(classRoot, orderEntry); } } } } RootInfo rootInfo = buildRootInfo(myProject); result = ContainerUtil.newHashMap(); Set<VirtualFile> allRoots = rootInfo.getAllRoots(); for (VirtualFile file : allRoots) { List<VirtualFile> hierarchy = getHierarchy(file, allRoots, rootInfo); result.put( file, hierarchy == null ? OrderEntry.EMPTY_ARRAY : calcOrderEntries( rootInfo, depEntries, libClassRootEntries, libSourceRootEntries, hierarchy)); } myOrderEntries = result; return result; }
@Nullable public static VirtualFile suggestManifestFileDirectory( @NotNull Project project, @Nullable Module module) { OrderEnumerator enumerator = module != null ? OrderEnumerator.orderEntries(module) : OrderEnumerator.orderEntries(project); final VirtualFile[] files = enumerator .withoutDepModules() .withoutLibraries() .withoutSdk() .productionOnly() .sources() .getRoots(); if (files.length > 0) { return files[0]; } return suggestBaseDir(project, null); }
private void assertClasspath(String moduleName, Scope scope, Type type, String... expectedPaths) throws Exception { createOutputDirectories(); PathsList actualPathsList; Module module = getModule(moduleName); if (scope == Scope.RUNTIME) { JavaParameters params = new JavaParameters(); params.configureByModule( module, type == Type.TESTS ? JavaParameters.CLASSES_AND_TESTS : JavaParameters.CLASSES_ONLY); actualPathsList = params.getClassPath(); } else { OrderEnumerator en = OrderEnumerator.orderEntries(module).recursively().withoutSdk().compileOnly(); if (type == Type.PRODUCTION) en.productionOnly(); actualPathsList = en.classes().getPathsList(); } assertPaths(expectedPaths, actualPathsList.getPathList()); }
public static List<SDependency> calculateLibraryDependencies( OrderEnumerator orderEnumerator, final Project project, final boolean includeStubs) { final Map<SModule, Boolean> modules = new HashMap<SModule, Boolean>(); orderEnumerator.forEach( new Processor<OrderEntry>() { public boolean process(OrderEntry oe) { if (!(oe instanceof LibraryOrderEntry)) { return true; } LibraryOrderEntry loe = (LibraryOrderEntry) oe; Library library = loe.getLibrary(); if (loe.isModuleLevel() || library == null) { return true; } if (ModuleLibraryType.isModuleLibrary(library)) { Set<SModuleReference> moduleReferences = ModuleLibrariesUtil.getModules(library); for (SModuleReference moduleReference : moduleReferences) { SModule m = moduleReference.resolve(MPSModuleRepository.getInstance()); // FIXME module repo if (m == null) { continue; } if (modules.containsKey(moduleReference)) { if (loe.isExported()) { modules.put(m, true); } } else { modules.put(m, loe.isExported()); } } } else if (includeStubs) { // try to find stub solution SModule s = MPSModuleRepository.getInstance().getModule(ModuleId.foreign(library.getName())); if (s != null) { modules.put(s, loe.isExported()); } } return true; } }); List<SDependency> result = new ArrayList<SDependency>(); for (Entry<SModule, Boolean> entry : modules.entrySet()) { result.add(new SDependencyImpl(entry.getKey(), SDependencyScope.DEFAULT, entry.getValue())); } return result; }
@Nullable protected static VirtualFile findGroovyJar(@NotNull Module module) { final VirtualFile[] files = OrderEnumerator.orderEntries(module).getAllLibrariesAndSdkClassesRoots(); for (VirtualFile root : files) { if (root.getName().matches(GroovyConfigUtils.GROOVY_JAR_PATTERN) || GroovyConfigUtils.matchesGroovyAll(root.getName())) { return root; } } for (VirtualFile file : files) { if (file.getName().contains("groovy") && "jar".equals(file.getExtension())) { return file; } } return null; }
public PathsList getApplicationClassPath(Module module) { final List<VirtualFile> classPath = OrderEnumerator.orderEntries(module) .recursively() .withoutSdk() .getPathsList() .getVirtualFiles(); retainOnlyJarsAndDirectories(classPath); removeModuleOutput(module, classPath); final Module pluginsModule = findCommonPluginsModule(module); if (pluginsModule != null) { removeModuleOutput(pluginsModule, classPath); } return removeFrameworkStuff(module, classPath); }