| /* |
| * Copyright 2000-2014 JetBrains s.r.o. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.jetbrains.plugins.groovy.mvc; |
| |
| import com.intellij.lang.properties.psi.PropertiesFile; |
| import com.intellij.openapi.application.AccessToken; |
| import com.intellij.openapi.application.ApplicationManager; |
| import com.intellij.openapi.application.WriteAction; |
| import com.intellij.openapi.diagnostic.Logger; |
| import com.intellij.openapi.module.ModifiableModuleModel; |
| import com.intellij.openapi.module.Module; |
| import com.intellij.openapi.module.ModuleManager; |
| import com.intellij.openapi.module.StdModuleTypes; |
| import com.intellij.openapi.project.Project; |
| import com.intellij.openapi.roots.*; |
| import com.intellij.openapi.roots.impl.ModifiableModelCommitter; |
| import com.intellij.openapi.roots.libraries.Library; |
| import com.intellij.openapi.roots.libraries.LibraryTable; |
| import com.intellij.openapi.roots.libraries.LibraryUtil; |
| import com.intellij.openapi.roots.ui.configuration.actions.ModuleDeleteProvider; |
| import com.intellij.openapi.util.Comparing; |
| import com.intellij.openapi.util.Key; |
| import com.intellij.openapi.vfs.LocalFileSystem; |
| import com.intellij.openapi.vfs.VfsUtil; |
| import com.intellij.openapi.vfs.VirtualFile; |
| import com.intellij.openapi.vfs.VirtualFileManager; |
| import com.intellij.psi.PsiFile; |
| import com.intellij.psi.PsiManager; |
| import com.intellij.util.ArrayUtil; |
| import com.intellij.util.CommonProcessors; |
| import com.intellij.util.Consumer; |
| import com.intellij.util.SmartList; |
| import com.intellij.util.containers.ContainerUtil; |
| import com.intellij.util.containers.MultiMap; |
| import org.jetbrains.annotations.NonNls; |
| import org.jetbrains.annotations.NotNull; |
| import org.jetbrains.annotations.Nullable; |
| import org.jetbrains.jps.model.java.JavaSourceRootType; |
| import org.jetbrains.jps.model.module.JpsModuleSourceRootType; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.util.*; |
| |
| /** |
| * @author peter |
| */ |
| public class MvcModuleStructureUtil { |
| private static final Logger LOG = Logger.getInstance("#org.jetbrains.plugins.groovy.mvc.MvcModuleStructureUtil"); |
| @NonNls public static final String PLUGINS_DIRECTORY = "plugins"; |
| @NonNls public static final String APPLICATION_PROPERTIES = "application.properties"; |
| public static final Key<String> LAST_MVC_VERSION = Key.create("LAST_MVC_VERSION"); |
| |
| private MvcModuleStructureUtil() { |
| } |
| |
| @Nullable |
| public static ContentEntry findContentEntry(ModuleRootModel rootModel, VirtualFile root) { |
| for (ContentEntry entry : rootModel.getContentEntries()) { |
| if (Comparing.equal(entry.getFile(), root)) { |
| return entry; |
| } |
| } |
| |
| return null; |
| } |
| |
| @Nullable |
| private static Consumer<ModifiableRootModel> addSourceRootsAndLibDirectory(@NotNull final VirtualFile root, |
| final MvcProjectStructure structure) { |
| ModuleRootManager moduleRootManager = ModuleRootManager.getInstance(structure.myModule); |
| |
| Map<VirtualFile, JpsModuleSourceRootType<?>> sourceRoots = new HashMap<VirtualFile, JpsModuleSourceRootType<?>>(); |
| for (ContentEntry entry : moduleRootManager.getContentEntries()) { |
| for (SourceFolder folder : entry.getSourceFolders()) { |
| sourceRoots.put(folder.getFile(), folder.getRootType()); |
| } |
| } |
| |
| root.refresh(false, true); |
| |
| final List<Consumer<ContentEntry>> actions = ContainerUtil.newArrayList(); |
| |
| for (Map.Entry<JpsModuleSourceRootType<?>, Collection<String>> entry : structure.getSourceFolders().entrySet()) { |
| JpsModuleSourceRootType<?> rootType = entry.getKey(); |
| |
| for (String src : entry.getValue()) { |
| addSourceFolder(root, src, rootType, actions, sourceRoots); |
| } |
| } |
| |
| for (final String src : structure.getInvalidSourceFolders()) { |
| removeSrcFolderFromRoots(root.findFileByRelativePath(src), actions, sourceRoots); |
| } |
| |
| for (final VirtualFile excluded : structure.getExcludedFolders(root)) { |
| if (moduleRootManager.getFileIndex().isInContent(excluded)) { |
| actions.add(new Consumer<ContentEntry>() { |
| @Override |
| public void consume(ContentEntry contentEntry) { |
| contentEntry.addExcludeFolder(excluded); |
| } |
| }); |
| } |
| } |
| |
| final Consumer<ModifiableRootModel> modifyLib = addJarDirectory(root, structure.myModule, structure.getUserLibraryName()); |
| |
| if (actions.isEmpty() && modifyLib == null && findContentEntry(moduleRootManager, root) != null) { |
| return null; |
| } |
| |
| return new Consumer<ModifiableRootModel>() { |
| @Override |
| public void consume(ModifiableRootModel model) { |
| ContentEntry contentEntry = findContentEntry(model, root); |
| if (contentEntry == null) { |
| contentEntry = model.addContentEntry(root); |
| } |
| |
| for (final Consumer<ContentEntry> action : actions) { |
| action.consume(contentEntry); |
| } |
| if (modifyLib != null) { |
| modifyLib.consume(model); |
| } |
| } |
| }; |
| } |
| |
| public static void removeSrcFolderFromRoots(final VirtualFile file, |
| @NotNull List<Consumer<ContentEntry>> actions, |
| @NotNull Map<VirtualFile, JpsModuleSourceRootType<?>> sourceRoots) { |
| removeSrcFolderFromRoots(file, actions, sourceRoots.keySet()); |
| } |
| |
| public static void removeSrcFolderFromRoots(final VirtualFile file, |
| @NotNull List<Consumer<ContentEntry>> actions, |
| @NotNull Collection<VirtualFile> sourceRoots) { |
| if (sourceRoots.contains(file)) { |
| actions.add(new Consumer<ContentEntry>() { |
| @Override |
| public void consume(ContentEntry contentEntry) { |
| SourceFolder[] folders = contentEntry.getSourceFolders(); |
| for (SourceFolder folder : folders) { |
| if (Comparing.equal(folder.getFile(), file)) { |
| contentEntry.removeSourceFolder(folder); |
| } |
| } |
| } |
| }); |
| } |
| } |
| |
| @Nullable |
| public static Consumer<ModifiableRootModel> addJarDirectory(VirtualFile root, Module module, final String libName) { |
| final VirtualFile libDir = root.findFileByRelativePath("lib"); |
| if (libDir == null || !libDir.isDirectory() || ProjectRootManager.getInstance(module.getProject()).getFileIndex().isExcluded(libDir)) { |
| return null; |
| } |
| |
| final Library library = findUserLibrary(module, libName); |
| if (library != null && library.isJarDirectory(libDir.getUrl())) { |
| return null; |
| } |
| |
| return new Consumer<ModifiableRootModel>() { |
| @Override |
| public void consume(ModifiableRootModel model) { |
| Library.ModifiableModel libModel = modifyDefaultLibrary(model, libName); |
| libModel.addJarDirectory(libDir, false); |
| libModel.commit(); |
| } |
| }; |
| } |
| |
| public static Library.ModifiableModel modifyDefaultLibrary(ModifiableRootModel model, String libName) { |
| LibraryTable libTable = model.getModuleLibraryTable(); |
| |
| for (Library library : libTable.getLibraries()) { |
| if (library.getName() != null && library.getName().startsWith(libName)) { |
| return library.getModifiableModel(); |
| } |
| } |
| |
| Library library = LibraryUtil.createLibrary(libTable, libName + " (" + model.getModule().getName() + ')'); |
| |
| for (OrderEntry entry : model.getOrderEntries()) { |
| if (!(entry instanceof LibraryOrderEntry)) continue; |
| |
| LibraryOrderEntry libraryEntry = (LibraryOrderEntry)entry; |
| if (libraryEntry.isModuleLevel() && libraryEntry.getLibrary() == library) { |
| libraryEntry.setExported(true); |
| } |
| } |
| |
| return library.getModifiableModel(); |
| } |
| |
| private static void addSourceFolder(@NotNull VirtualFile root, |
| @NotNull String relativePath, |
| final JpsModuleSourceRootType<?> rootType, |
| List<Consumer<ContentEntry>> actions, |
| Map<VirtualFile, JpsModuleSourceRootType<?>> sourceRoots) { |
| final VirtualFile src = root.findFileByRelativePath(relativePath); |
| if (src == null) { |
| return; |
| } |
| |
| JpsModuleSourceRootType<?> existingRootType = sourceRoots.get(src); |
| |
| if (rootType == JavaSourceRootType.TEST_SOURCE && (existingRootType != null && existingRootType != JavaSourceRootType.TEST_SOURCE)) { // see http://youtrack.jetbrains.net/issue/IDEA-70642 |
| actions.add(new Consumer<ContentEntry>() { |
| @Override |
| public void consume(ContentEntry entry) { |
| for (SourceFolder folder : entry.getSourceFolders()) { |
| if (Comparing.equal(folder.getFile(), src)) { |
| entry.removeSourceFolder(folder); |
| entry.addSourceFolder(src, rootType); |
| break; |
| } |
| } |
| } |
| }); |
| return; |
| } |
| |
| actions.add(new Consumer<ContentEntry>() { |
| @Override |
| public void consume(ContentEntry contentEntry) { |
| contentEntry.addSourceFolder(src, rootType); |
| } |
| }); |
| } |
| |
| public static void updateModuleStructure(Module module, MvcProjectStructure structure, @NotNull VirtualFile root) { |
| List<Consumer<ModifiableRootModel>> actions = getUpdateProjectStructureActions(Collections.singletonList(root), structure); |
| |
| if (!actions.isEmpty()) { |
| final ModifiableRootModel model = ModuleRootManager.getInstance(module).getModifiableModel(); |
| boolean success = false; |
| try { |
| for (final Consumer<ModifiableRootModel> action : actions) { |
| action.consume(model); |
| } |
| model.commit(); |
| success = true; |
| } |
| finally { |
| if (!success) { |
| model.dispose(); |
| } |
| } |
| } |
| } |
| |
| private static boolean checkValidity(VirtualFile pluginDir) { |
| pluginDir.refresh(false, false); |
| return pluginDir.isValid(); |
| } |
| |
| private static List<Consumer<ModifiableRootModel>> getUpdateProjectStructureActions(Collection<VirtualFile> appRoots, |
| MvcProjectStructure structure) { |
| for (final VirtualFile appRoot : ModuleRootManager.getInstance(structure.myModule).getContentRoots()) { |
| appRoot.refresh(false, false); |
| } |
| |
| List<Consumer<ModifiableRootModel>> actions = ContainerUtil.newArrayList(); |
| removeInvalidSourceRoots(actions, structure); |
| cleanupDefaultLibrary(structure.myModule, actions, appRoots, structure.getUserLibraryName()); |
| moveupLibrariesFromMavenPlugin(structure.myModule, actions); |
| |
| List<VirtualFile> rootsToFacetSetup = new ArrayList<VirtualFile>(appRoots.size()); |
| for (VirtualFile appRoot : appRoots) { |
| if (checkValidity(appRoot)) { |
| ContainerUtil.addIfNotNull(addSourceRootsAndLibDirectory(appRoot, structure), actions); |
| rootsToFacetSetup.add(appRoot); |
| } |
| } |
| |
| List<Runnable> facetActions = new ArrayList<Runnable>(); |
| structure.setupFacets(facetActions, rootsToFacetSetup); |
| for (final Runnable action : facetActions) { |
| actions.add(new Consumer<ModifiableRootModel>() { |
| @Override |
| public void consume(ModifiableRootModel model) { |
| action.run(); |
| } |
| }); |
| } |
| |
| return actions; |
| } |
| |
| @Nullable |
| private static OrderEntry[] moveupLibrariesFromMavenPlugin(ModuleRootModel moduleRootModel) { |
| LibraryOrderEntry newestLibrary = null; |
| int firstLibraryIndex = 0; |
| int newestLibraryIndex = 0; |
| |
| OrderEntry[] orderEntries = moduleRootModel.getOrderEntries(); |
| for (int i = 0; i < orderEntries.length; i++) { |
| if (orderEntries[i] instanceof LibraryOrderEntry) { |
| LibraryOrderEntry libraryEntry = (LibraryOrderEntry)orderEntries[i]; |
| String libraryName = libraryEntry.getLibraryName(); |
| if (libraryName != null && libraryName.contains("slf4j-api")) { |
| if (newestLibrary == null) { |
| newestLibrary = libraryEntry; |
| firstLibraryIndex = i; |
| newestLibraryIndex = i; |
| } |
| else { |
| if (libraryName.compareTo(newestLibrary.getLibraryName()) > 0) { |
| newestLibraryIndex = i; |
| newestLibrary = libraryEntry; |
| } |
| } |
| } |
| } |
| } |
| |
| if (firstLibraryIndex == newestLibraryIndex) return null; |
| |
| OrderEntry[] res = orderEntries.clone(); |
| ArrayUtil.swap(res, firstLibraryIndex, newestLibraryIndex); |
| return res; |
| } |
| |
| private static void moveupLibrariesFromMavenPlugin(final Module module, List<Consumer<ModifiableRootModel>> actions) { |
| if (moveupLibrariesFromMavenPlugin(ModuleRootManager.getInstance(module)) != null) { |
| actions.add(new Consumer<ModifiableRootModel>() { |
| @Override |
| public void consume(ModifiableRootModel modifiableRootModel) { |
| OrderEntry[] orderEntries = moveupLibrariesFromMavenPlugin(modifiableRootModel); |
| if (orderEntries != null) { |
| modifiableRootModel.rearrangeOrderEntries(orderEntries); |
| } |
| } |
| }); |
| } |
| } |
| |
| private static void removeInvalidSourceRoots(List<Consumer<ModifiableRootModel>> actions, MvcProjectStructure structure) { |
| final Set<SourceFolder> toRemove = ContainerUtil.newTroveSet(); |
| final Set<String> toRemoveContent = ContainerUtil.newTroveSet(); |
| for (ContentEntry entry : ModuleRootManager.getInstance(structure.myModule).getContentEntries()) { |
| final VirtualFile file = entry.getFile(); |
| if (file == null || !structure.isValidContentRoot(file)) { |
| toRemoveContent.add(entry.getUrl()); |
| } |
| else { |
| for (SourceFolder folder : entry.getSourceFolders()) { |
| if (folder.getFile() == null) { |
| toRemove.add(folder); |
| } |
| } |
| } |
| } |
| |
| if (!toRemove.isEmpty() || !toRemoveContent.isEmpty()) { |
| actions.add(new Consumer<ModifiableRootModel>() { |
| @Override |
| public void consume(ModifiableRootModel model) { |
| for (ContentEntry entry : model.getContentEntries()) { |
| if (toRemoveContent.remove(entry.getUrl())) { |
| model.removeContentEntry(entry); |
| } |
| else { |
| for (SourceFolder folder : entry.getSourceFolders()) { |
| if (toRemove.remove(folder)) { |
| entry.removeSourceFolder(folder); |
| } |
| } |
| } |
| } |
| } |
| }); |
| } |
| } |
| |
| public static void cleanupDefaultLibrary(Module module, |
| List<Consumer<ModifiableRootModel>> actions, |
| Collection<VirtualFile> appRoots, |
| final String libName) { |
| final Library library = findUserLibrary(module, libName); |
| if (library == null) { |
| return; |
| } |
| |
| final VirtualFileManager virtualFileManager = VirtualFileManager.getInstance(); |
| |
| final List<String> toRemoveUrls = new ArrayList<String>(); |
| |
| for (String url : library.getUrls(OrderRootType.CLASSES)) { |
| VirtualFile virtualFile = virtualFileManager.findFileByUrl(url); |
| |
| if (virtualFile == null) { |
| toRemoveUrls.add(url); |
| } |
| else { |
| if (library.isJarDirectory(url)) { |
| if (!virtualFile.getName().equals("lib") || !appRoots.contains(virtualFile.getParent())) { |
| toRemoveUrls.add(url); |
| } |
| } |
| } |
| } |
| |
| if (!toRemoveUrls.isEmpty()) { |
| actions.add(new Consumer<ModifiableRootModel>() { |
| @Override |
| public void consume(ModifiableRootModel model) { |
| final Library.ModifiableModel modifiableModel = modifyDefaultLibrary(model, libName); |
| for (String url : toRemoveUrls) { |
| modifiableModel.removeRoot(url, OrderRootType.CLASSES); |
| } |
| modifiableModel.commit(); |
| } |
| }); |
| } |
| } |
| |
| public static boolean hasModulesWithSupport(Project project, final MvcFramework framework) { |
| for (Module module : ModuleManager.getInstance(project).getModules()) { |
| if (framework.hasSupport(module)) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| public static List<Module> getAllModulesWithSupport(Project project, MvcFramework framework) { |
| List<Module> modules = new ArrayList<Module>(); |
| for (Module module : ModuleManager.getInstance(project).getModules()) { |
| if (framework.hasSupport(module)) { |
| modules.add(module); |
| } |
| } |
| return modules; |
| } |
| |
| @Nullable |
| private static Library extractNonModuleLibraries(List<Library> result, |
| ModuleRootManager rootManager, |
| boolean providedOnly, |
| String userLibraryName) { |
| Library userLibrary = null; |
| |
| for (OrderEntry entry : rootManager.getOrderEntries()) { |
| if (entry instanceof LibraryOrderEntry) { |
| LibraryOrderEntry libraryEntry = (LibraryOrderEntry)entry; |
| Library library = libraryEntry.getLibrary(); |
| |
| if (library != null) { |
| String libraryName = libraryEntry.getLibraryName(); |
| if (libraryName != null && libraryName.startsWith(userLibraryName)) { |
| userLibrary = library; |
| } |
| else { |
| if (library.getTable() != null && (!providedOnly || !libraryEntry.getScope().isForProductionRuntime())) { |
| result.add(library); |
| } |
| } |
| } |
| } |
| } |
| |
| return userLibrary; |
| } |
| |
| private static Set<String> getJarUrls(@Nullable Library library) { |
| if (library == null) return Collections.emptySet(); |
| |
| Set<String> res = new HashSet<String>(); |
| |
| for (String url : library.getUrls(OrderRootType.CLASSES)) { |
| if (!library.isJarDirectory(url)) { |
| res.add(url); |
| } |
| } |
| |
| return res; |
| } |
| |
| public static void syncAuxModuleSdk(@NotNull Module appModule, @NotNull Module pluginsModule, @NotNull final MvcFramework framework) { |
| final ModuleRootManager auxRootManager = ModuleRootManager.getInstance(pluginsModule); |
| final ModuleRootManager appRootManager = ModuleRootManager.getInstance(appModule); |
| |
| final boolean isSdkEquals = Comparing.equal(auxRootManager.getSdk(), appRootManager.getSdk()); |
| |
| List<Library> appLibraries = new ArrayList<Library>(); |
| Library appUserLibrary = extractNonModuleLibraries(appLibraries, appRootManager, false, framework.getUserLibraryName()); |
| |
| List<Library> auxLibraries = new ArrayList<Library>(); |
| Library auxUserLibrary = extractNonModuleLibraries(auxLibraries, auxRootManager, false, framework.getUserLibraryName()); |
| |
| final boolean isLibrariesEquals = appLibraries.equals(auxLibraries) && getJarUrls(auxUserLibrary).equals(getJarUrls(appUserLibrary)); |
| |
| if (!isSdkEquals || !isLibrariesEquals) { |
| AccessToken token = WriteAction.start(); |
| try { |
| final ModifiableRootModel model = auxRootManager.getModifiableModel(); |
| |
| if (!isSdkEquals) { |
| copySdk(appRootManager, model); |
| } |
| |
| if (!isLibrariesEquals) { |
| copyUserLibraries(appRootManager, model, framework); |
| } |
| |
| model.commit(); |
| } |
| finally { |
| token.finish(); |
| } |
| } |
| } |
| |
| @Nullable |
| public static PropertiesFile findApplicationProperties(@NotNull Module module, MvcFramework framework) { |
| VirtualFile root = framework.findAppRoot(module); |
| if (root == null) return null; |
| |
| VirtualFile appChild = root.findChild(APPLICATION_PROPERTIES); |
| if (appChild == null || !appChild.isValid()) return null; |
| |
| PsiManager manager = PsiManager.getInstance(module.getProject()); |
| PsiFile psiFile = manager.findFile(appChild); |
| if (psiFile instanceof PropertiesFile) { |
| return (PropertiesFile)psiFile; |
| } |
| return null; |
| } |
| |
| public static void removeAuxiliaryModule(Module toRemove) { |
| List<ModifiableRootModel> usingModels = new SmartList<ModifiableRootModel>(); |
| |
| Project project = toRemove.getProject(); |
| ModuleManager moduleManager = ModuleManager.getInstance(project); |
| |
| for (Module module : moduleManager.getModules()) { |
| if (module == toRemove) { |
| continue; |
| } |
| |
| ModuleRootManager moduleRootManager = ModuleRootManager.getInstance(module); |
| for (OrderEntry entry : moduleRootManager.getOrderEntries()) { |
| if (entry instanceof ModuleOrderEntry && toRemove == ((ModuleOrderEntry)entry).getModule()) { |
| usingModels.add(moduleRootManager.getModifiableModel()); |
| break; |
| } |
| } |
| } |
| |
| final ModifiableModuleModel moduleModel = moduleManager.getModifiableModel(); |
| |
| ModuleDeleteProvider.removeModule(toRemove, null, usingModels, moduleModel); |
| |
| ModifiableRootModel[] rootModels = usingModels.toArray(new ModifiableRootModel[usingModels.size()]); |
| ModifiableModelCommitter.multiCommit(rootModels, moduleModel); |
| } |
| |
| @NotNull |
| public static Module createAuxiliaryModule(@NotNull Module appModule, final String moduleName, final MvcFramework framework) { |
| ModuleManager moduleManager = ModuleManager.getInstance(appModule.getProject()); |
| final ModifiableModuleModel moduleModel = moduleManager.getModifiableModel(); |
| final String moduleFilePath = new File(appModule.getModuleFilePath()).getParent() + "/" + moduleName + ".iml"; |
| final VirtualFile existing = LocalFileSystem.getInstance().findFileByPath(moduleFilePath); |
| if (existing != null) { |
| try { |
| existing.delete("Grails/Griffon plugins maintenance"); |
| } |
| catch (IOException e) { |
| LOG.error(e); |
| } |
| } |
| |
| moduleModel.newModule(moduleFilePath, StdModuleTypes.JAVA.getId()); |
| moduleModel.commit(); |
| |
| Module pluginsModule = moduleManager.findModuleByName(moduleName); |
| assert pluginsModule != null; |
| |
| ModifiableRootModel newRootModel = ModuleRootManager.getInstance(pluginsModule).getModifiableModel(); |
| ModifiableRootModel appModel = ModuleRootManager.getInstance(appModule).getModifiableModel(); |
| |
| copySdkAndLibraries(appModel, newRootModel, framework); |
| |
| newRootModel.commit(); |
| appModel.commit(); |
| |
| return pluginsModule; |
| } |
| |
| public static void ensureDependency(@NotNull Module from, @NotNull Module to, boolean exported) { |
| if (!from.equals(to) && !hasDependency(from, to)) { |
| ModuleRootModificationUtil.addDependency(from, to, DependencyScope.COMPILE, exported); |
| } |
| } |
| |
| public static boolean hasDependency(@NotNull Module from, @NotNull Module to) { |
| for (OrderEntry entry : ModuleRootManager.getInstance(from).getOrderEntries()) { |
| if (entry instanceof ModuleOrderEntry) { |
| final ModuleOrderEntry moduleOrderEntry = (ModuleOrderEntry)entry; |
| if (to == moduleOrderEntry.getModule()) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| public static void removeDependency(@NotNull Module from, @NotNull Module to) { |
| if (!from.equals(to) && hasDependency(from, to)) { |
| final ModifiableRootModel fromModel = ModuleRootManager.getInstance(from).getModifiableModel(); |
| for (OrderEntry entry : fromModel.getOrderEntries()) { |
| if (entry instanceof ModuleOrderEntry) { |
| final ModuleOrderEntry moduleOrderEntry = (ModuleOrderEntry)entry; |
| if (to == moduleOrderEntry.getModule()) { |
| fromModel.removeOrderEntry(moduleOrderEntry); |
| } |
| } |
| } |
| fromModel.commit(); |
| } |
| } |
| |
| public static void copySdk(ModuleRootModel from, ModifiableRootModel to) { |
| if (from.isSdkInherited()) { |
| to.inheritSdk(); |
| } |
| else { |
| to.setSdk(from.getSdk()); |
| } |
| } |
| |
| public static void copySdkAndLibraries(ModuleRootModel from, ModifiableRootModel to, @NotNull MvcFramework framework) { |
| copySdk(from, to); |
| copyUserLibraries(from, to, framework); |
| } |
| |
| public static void copyUserLibraries(ModuleRootModel from, ModifiableRootModel to, @NotNull MvcFramework framework) { |
| Library userLibraryTo = null; |
| |
| for (OrderEntry entry : to.getOrderEntries()) { |
| if (entry instanceof LibraryOrderEntry) { |
| LibraryOrderEntry libraryEntry = (LibraryOrderEntry)entry; |
| Library library = libraryEntry.getLibrary(); |
| |
| if (library != null) { |
| String libraryName = libraryEntry.getLibraryName(); |
| if (libraryName != null && libraryName.startsWith(framework.getUserLibraryName())) { |
| userLibraryTo = library; |
| } |
| else { |
| if (library.getTable() != null && (!libraryEntry.getScope().isForProductionRuntime() || framework.isSDKLibrary(library))) { |
| to.removeOrderEntry(entry); |
| } |
| } |
| } |
| } |
| } |
| |
| Library userLibraryFrom = null; |
| |
| for (OrderEntry entry : from.getOrderEntries()) { |
| if (entry instanceof LibraryOrderEntry) { |
| LibraryOrderEntry libraryEntry = (LibraryOrderEntry)entry; |
| Library library = libraryEntry.getLibrary(); |
| |
| if (library != null) { |
| String libraryName = library.getName(); |
| if (libraryName != null && libraryName.startsWith(framework.getUserLibraryName())) { |
| userLibraryFrom = library; |
| } |
| else { |
| if (library.getTable() != null) { |
| LibraryOrderEntry libraryOrderEntry = to.addLibraryEntry(library); |
| libraryOrderEntry.setScope(DependencyScope.PROVIDED); |
| } |
| } |
| } |
| } |
| } |
| |
| if (userLibraryTo == null) { |
| if (userLibraryFrom == null) return; |
| |
| userLibraryTo = to.getModuleLibraryTable().createLibrary(framework.getUserLibraryName() + " (" + to.getModule().getName() + ')'); |
| } |
| else { |
| OrderEntry[] orderEntries = to.getOrderEntries().clone(); |
| |
| for (int i = 0; i < orderEntries.length; i++) { |
| OrderEntry orderEntry = orderEntries[i]; |
| if (orderEntry instanceof LibraryOrderEntry) { |
| if (userLibraryTo == ((LibraryOrderEntry)orderEntry).getLibrary()) { |
| System.arraycopy(orderEntries, i + 1, orderEntries, i, orderEntries.length - i - 1); |
| orderEntries[orderEntries.length - 1] = orderEntry; |
| to.rearrangeOrderEntries(orderEntries); |
| break; |
| } |
| } |
| } |
| } |
| |
| Library.ModifiableModel model = userLibraryTo.getModifiableModel(); |
| for (String url : model.getUrls(OrderRootType.CLASSES)) { |
| if (!model.isJarDirectory(url)) { |
| model.removeRoot(url, OrderRootType.CLASSES); |
| } |
| } |
| |
| if (userLibraryFrom != null) { |
| for (String url : userLibraryFrom.getUrls(OrderRootType.CLASSES)) { |
| if (!userLibraryFrom.isJarDirectory(url)) { |
| model.addRoot(url, OrderRootType.CLASSES); |
| } |
| } |
| } |
| |
| model.commit(); |
| } |
| |
| public static Consumer<ModifiableRootModel> removeStaleContentEntries(final Collection<VirtualFile> pluginDirs) { |
| return new Consumer<ModifiableRootModel>() { |
| @Override |
| public void consume(ModifiableRootModel modifiableRootModel) { |
| for (final ContentEntry entry : modifiableRootModel.getContentEntries()) { |
| if (!pluginDirs.contains(entry.getFile())) { |
| modifiableRootModel.removeContentEntry(entry); |
| } |
| } |
| } |
| }; |
| } |
| |
| public static void updateAuxModuleStructure(Module auxModule, Collection<VirtualFile> pluginDirs, MvcFramework framework) { |
| final MvcProjectStructure structure = framework.createProjectStructure(auxModule, true); |
| final List<Consumer<ModifiableRootModel>> actions = getUpdateProjectStructureActions(pluginDirs, structure); |
| for (final ContentEntry root : ModuleRootManager.getInstance(auxModule).getContentEntries()) { |
| if (!pluginDirs.contains(root.getFile())) { |
| actions.add(removeStaleContentEntries(pluginDirs)); |
| break; |
| } |
| } |
| |
| if (!actions.isEmpty()) { |
| actions.add(exportDefaultLibrary(structure.getUserLibraryName())); |
| } |
| |
| if (!actions.isEmpty()) { |
| final ModifiableRootModel model = ModuleRootManager.getInstance(auxModule).getModifiableModel(); |
| for (final Consumer<ModifiableRootModel> pluginsUpdateAction : actions) { |
| pluginsUpdateAction.consume(model); |
| } |
| model.commit(); |
| } |
| } |
| |
| public static Consumer<ModifiableRootModel> exportDefaultLibrary(final String libraryName) { |
| return new Consumer<ModifiableRootModel>() { |
| @Override |
| public void consume(ModifiableRootModel modifiableRootModel) { |
| for (final OrderEntry entry : modifiableRootModel.getOrderEntries()) { |
| if (entry instanceof LibraryOrderEntry) { |
| final LibraryOrderEntry libraryOrderEntry = (LibraryOrderEntry)entry; |
| String lName = libraryOrderEntry.getLibraryName(); |
| if (lName != null && lName.startsWith(libraryName)) { |
| libraryOrderEntry.setExported(true); |
| } |
| } |
| } |
| } |
| }; |
| } |
| |
| private static boolean hasChildDirectory(VirtualFile file) { |
| for (VirtualFile virtualFile : file.getChildren()) { |
| if (virtualFile.isDirectory()) return true; |
| } |
| |
| return false; |
| } |
| |
| public static void updateGlobalPluginModule(@NotNull Project project, @NotNull MvcFramework framework) { |
| MultiMap<VirtualFile, Module> map = new MultiMap<VirtualFile, Module>(); |
| |
| for (Module module : ModuleManager.getInstance(project).getModules()) { |
| if (framework.hasSupport(module)) { |
| VirtualFile globalPluginsDir = refreshAndFind(framework.getGlobalPluginsDir(module)); |
| if (globalPluginsDir != null && hasChildDirectory(globalPluginsDir)) { |
| map.putValue(globalPluginsDir, module); |
| } |
| } |
| } |
| |
| Map<VirtualFile, Module> globalAuxModules = new HashMap<VirtualFile, Module>(); |
| |
| for (Module module : ModuleManager.getInstance(project).getModules()) { |
| if (framework.isGlobalPluginModule(module)) { |
| VirtualFile[] contentRoots = ModuleRootManager.getInstance(module).getContentRoots(); |
| |
| VirtualFile parent = null; |
| |
| if (contentRoots.length > 0) { |
| parent = contentRoots[0].getParent(); |
| if (!map.containsKey(parent)) { |
| parent = null; |
| } |
| else { |
| for (int i = 1; i < contentRoots.length; i++) { |
| if (!Comparing.equal(parent, contentRoots[i].getParent())) { |
| parent = null; |
| break; |
| } |
| } |
| } |
| } |
| |
| if (parent == null) { |
| removeAuxiliaryModule(module); |
| } |
| else { |
| globalAuxModules.put(parent, module); |
| } |
| } |
| } |
| |
| for (VirtualFile virtualFile : map.keySet()) { |
| if (!globalAuxModules.containsKey(virtualFile)) { |
| Module appModule = map.get(virtualFile).iterator().next(); |
| Module module = |
| createAuxiliaryModule(appModule, generateUniqueModuleName(project, framework.getGlobalPluginsModuleName()), framework); |
| globalAuxModules.put(virtualFile, module); |
| } |
| } |
| |
| assert map.size() == globalAuxModules.size(); |
| |
| for (VirtualFile virtualFile : map.keySet()) { |
| List<VirtualFile> pluginRoots = new ArrayList<VirtualFile>(); |
| |
| for (VirtualFile child : virtualFile.getChildren()) { |
| if (child.isDirectory()) { |
| pluginRoots.add(child); |
| } |
| } |
| |
| assert !pluginRoots.isEmpty(); |
| |
| Module auxModule = globalAuxModules.get(virtualFile); |
| |
| updateAuxModuleStructure(auxModule, pluginRoots, framework); |
| |
| for (Module appModule : map.get(virtualFile)) { |
| ensureDependency(appModule, auxModule, false); |
| |
| Module commonPluginsModule = framework.findCommonPluginsModule(appModule); |
| if (commonPluginsModule != null) { |
| ensureDependency(commonPluginsModule, auxModule, false); |
| } |
| } |
| } |
| } |
| |
| private static String generateUniqueModuleName(@NotNull Project project, String prefix) { |
| ModuleManager manager = ModuleManager.getInstance(project); |
| int i = 0; |
| do { |
| String res = i == 0 ? prefix : prefix + i; |
| i++; |
| |
| if (manager.findModuleByName(res) == null) return res; |
| } |
| while (true); |
| } |
| |
| @Nullable |
| public static Module updateAuxiliaryPluginsModuleRoots(Module appModule, MvcFramework framework) { |
| Module commonPluginsModule = framework.findCommonPluginsModule(appModule); |
| |
| Set<VirtualFile> pluginRoots = new HashSet<VirtualFile>(); |
| |
| VirtualFile globalPluginsDir = refreshAndFind(framework.getGlobalPluginsDir(appModule)); |
| |
| for (VirtualFile pluginRoot : framework.getCommonPluginRoots(appModule, true)) { |
| if (checkValidity(pluginRoot)) { |
| if (globalPluginsDir == null || !VfsUtil.isAncestor(globalPluginsDir, pluginRoot, true)) { |
| pluginRoots.add(pluginRoot); |
| } |
| } |
| } |
| |
| if (pluginRoots.isEmpty()) { |
| if (commonPluginsModule != null) { |
| removeAuxiliaryModule(commonPluginsModule); |
| } |
| return null; |
| } |
| |
| if (commonPluginsModule == null) { |
| commonPluginsModule = createAuxiliaryModule(appModule, framework.getCommonPluginsModuleName(appModule), framework); |
| } |
| |
| ensureDependency(appModule, commonPluginsModule, false); |
| updateAuxModuleStructure(commonPluginsModule, pluginRoots, framework); |
| |
| return commonPluginsModule; |
| } |
| |
| public static Library findUserLibrary(@NotNull Module module, @NotNull final String name) { |
| CommonProcessors.FindProcessor<Library> processor = new CommonProcessors.FindProcessor<Library>() { |
| @Override |
| protected boolean accept(Library library) { |
| String libraryName = library.getName(); |
| return libraryName != null && libraryName.startsWith(name); |
| } |
| }; |
| |
| OrderEnumerator.orderEntries(module).forEachLibrary(processor); |
| |
| return processor.getFoundValue(); |
| } |
| |
| @Nullable |
| public static VirtualFile refreshAndFind(@Nullable File file) { |
| return findFile(file, true); |
| } |
| |
| @Nullable |
| public static VirtualFile findFile(@Nullable File file, boolean refresh) { |
| if (file == null) return null; |
| |
| if (refresh) { |
| ApplicationManager.getApplication().assertIsDispatchThread(); |
| return LocalFileSystem.getInstance().refreshAndFindFileByIoFile(file); |
| } |
| else { |
| return LocalFileSystem.getInstance().findFileByIoFile(file); |
| } |
| } |
| |
| public static boolean isEnabledStructureUpdate() { |
| return !Boolean.parseBoolean(System.getProperty("grails.disable.structure.update")); |
| } |
| } |
