com.intellij.openapi.roots.ModifiableRootModel Java Examples

protected void unzip(@Nonnull ModifiableRootModel model) {
  InputStream resourceAsStream = getClass().getClassLoader().getResourceAsStream(myPath);
  if (resourceAsStream == null) {
    LOG.error("Resource by path '" + myPath + "' not found");
    return;
  }
  try {
    File tempFile = FileUtil.createTempFile("template", "zip");
    FileUtil.writeToFile(tempFile, FileUtil.loadBytes(resourceAsStream));
    final VirtualFile moduleDir = model.getModule().getModuleDir();

    File outputDir = VfsUtil.virtualToIoFile(moduleDir);

    ZipUtil.extract(tempFile, outputDir, null);
  }
  catch (IOException e) {
    LOG.error(e);
  }
}
 

@Override
public void setupRootModel(ModifiableRootModel rootModel) throws ConfigurationException {

    String s = new Gson().toJson(userChooseDependency);
    System.out.println("set up root model json is:" + s);
    Project project = rootModel.getProject();
    VirtualFile root = createAndGetContentEntry();
    rootModel.addContentEntry(root);
    if (myJdk != null) {
        rootModel.setSdk(myJdk);
    } else {
        rootModel.inheritSdk();
    }
    System.out.println("start to create folder in path");


}
 

@Override
public void setupRootModel(ModifiableRootModel rootModel) throws ConfigurationException {
    super.setupRootModel(rootModel);

    addListener(new ModuleBuilderListener() {
        @Override
        public void moduleCreated(@NotNull Module module) {
            setMuleFramework(module);
        }
    });

    setMuleFacet(rootModel.getModule());

    final Project project = rootModel.getProject();
    final VirtualFile root = createAndGetContentEntry();
    rootModel.addContentEntry(root);

    //Check if this is a module and has parent
    final MavenId parentId = (this.getParentProject() != null ? this.getParentProject().getMavenId() : null);

    MavenUtil.runWhenInitialized(project, (DumbAwareRunnable) () -> {
        new MuleMavenProjectBuilderHelper().configure(project, getProjectId(), muleVersion, root, parentId);
    });
}
 

protected static void addFlutterLibraryDependency(@NotNull Module module, @NotNull Library library) {
  final ModifiableRootModel modifiableModel = ModuleRootManager.getInstance(module).getModifiableModel();

  try {
    for (final OrderEntry orderEntry : modifiableModel.getOrderEntries()) {
      if (orderEntry instanceof LibraryOrderEntry &&
          LibraryTablesRegistrar.PROJECT_LEVEL.equals(((LibraryOrderEntry)orderEntry).getLibraryLevel()) &&
          StringUtil.equals(library.getName(), ((LibraryOrderEntry)orderEntry).getLibraryName())) {
        return; // dependency already exists
      }
    }

    modifiableModel.addLibraryEntry(library);

    ApplicationManager.getApplication().invokeAndWait(() -> WriteAction.run(modifiableModel::commit));
  }
  finally {
    if (!modifiableModel.isDisposed()) {
      modifiableModel.dispose();
    }
  }
}
 

@Override
@RequiredWriteAction
public void invoke(@Nonnull Project project, Editor editor, PsiFile file) throws IncorrectOperationException
{
	Module moduleForPsiElement = ModuleUtilCore.findModuleForPsiElement(file);
	if(moduleForPsiElement == null)
	{
		return;
	}

	ModuleRootManager moduleRootManager = ModuleRootManager.getInstance(moduleForPsiElement);

	final ModifiableRootModel modifiableModel = moduleRootManager.getModifiableModel();
	CSharpSimpleMutableModuleExtension cSharpModuleExtension = modifiableModel.getExtension(CSharpSimpleMutableModuleExtension.class);
	if(cSharpModuleExtension != null)
	{
		cSharpModuleExtension.setAllowUnsafeCode(true);
	}

	modifiableModel.commit();
}
 

@Override
public void setupRootModel(@NotNull ModifiableRootModel rootModel) {
    rootModel.inheritSdk();

    ContentEntry contentEntry = doAddContentEntry(rootModel);
    if (contentEntry != null) {
        List<Pair<String, String>> sourcePaths = getSourcePaths();

        if (sourcePaths != null) {
            for (final Pair<String, String> sourcePath : sourcePaths) {
                String first = sourcePath.first;
                boolean created = new File(first).mkdirs();
                if (created) {
                    VirtualFile sourceRoot = LocalFileSystem.getInstance().refreshAndFindFileByPath(FileUtil.toSystemIndependentName(first));
                    if (sourceRoot != null) {
                        contentEntry.addSourceFolder(sourceRoot, false, sourcePath.second);
                    }
                }
            }
        }
    }
}
 

private List<Module> getNotAddedModules() {
  final ModifiableRootModel rootModel = myClasspathPanel.getRootModel();
  Set<Module> addedModules = new HashSet<Module>(Arrays.asList(rootModel.getModuleDependencies(true)));
  addedModules.add(rootModel.getModule());

  final Module[] modules = myClasspathPanel.getModuleConfigurationState().getModulesProvider().getModules();
  final List<Module> elements = new ArrayList<Module>();
  for (final Module module : modules) {
    if (!addedModules.contains(module)) {
      elements.add(module);
    }
  }
  ContainerUtil.sort(elements, new Comparator<Module>() {
    @Override
    public int compare(Module o1, Module o2) {
      return StringUtil.compare(o1.getName(), o2.getName(), false);
    }
  });
  return elements;
}
 

protected static void removeFlutterLibraryDependency(@NotNull Module module, @NotNull Library library) {
  final ModifiableRootModel modifiableModel = ModuleRootManager.getInstance(module).getModifiableModel();

  try {
    boolean wasFound = false;

    for (final OrderEntry orderEntry : modifiableModel.getOrderEntries()) {
      if (orderEntry instanceof LibraryOrderEntry &&
          LibraryTablesRegistrar.PROJECT_LEVEL.equals(((LibraryOrderEntry)orderEntry).getLibraryLevel()) &&
          StringUtil.equals(library.getName(), ((LibraryOrderEntry)orderEntry).getLibraryName())) {
        wasFound = true;
        modifiableModel.removeOrderEntry(orderEntry);
      }
    }

    if (wasFound) {
      ApplicationManager.getApplication().invokeAndWait(() -> WriteAction.run(modifiableModel::commit));
    }
  }
  finally {
    if (!modifiableModel.isDisposed()) {
      modifiableModel.dispose();
    }
  }
}
 

@RequiredUIAccess
public AddModuleDependencyDialog(@Nonnull ClasspathPanel panel, StructureConfigurableContext context) {
  super(panel.getComponent(), true);

  ModifiableRootModel rootModel = panel.getRootModel();

  myTabs = new StripeTabPanel();

  for (AddModuleDependencyTabFactory factory : AddModuleDependencyTabFactory.EP_NAME.getExtensions()) {
    if(!factory.isAvailable(rootModel)) {
      continue;
    }
    AddModuleDependencyTabContext tabContext = factory.createTabContext(myDisposable, panel, context);

    JComponent component = tabContext.getComponent();
    JScrollPane scrollPane = ScrollPaneFactory.createScrollPane(component, true);

    StripeTabPanel.TabInfo tabInfo = myTabs.addTab(tabContext.getTabName(), scrollPane, component);
    tabInfo.setEnabled(!tabContext.isEmpty());
    tabInfo.putUserData(CONTEXT_KEY, tabContext);
  }

  setTitle("Add Dependencies");
  init();
}
 

private static Module createModule(
        ProjectDescriptor projectDescriptor,
        final ModuleDescriptor descriptor,
        final Map<LibraryDescriptor, Library> projectLibs,
        final ModifiableModuleModel moduleModel) {

    logger.info("Starting createModule in ProjectFromSourcesBuilderImplModified");
    final String moduleFilePath = descriptor.computeModuleFilePath();
    ModuleBuilder.deleteModuleFile(moduleFilePath);

    final Module module =
            moduleModel.newModule(moduleFilePath, descriptor.getModuleType().getId());
    final ModifiableRootModel modifiableModel =
            ModuleRootManager.getInstance(module).getModifiableModel();
    setupRootModel(projectDescriptor, descriptor, modifiableModel, projectLibs);
    descriptor.updateModuleConfiguration(module, modifiableModel);
    modifiableModel.commit();
    logger.info("ending createModule in ProjectFromSourcesBuilderImplModified");
    return module;
}
 

@Override
public void setupRootModel(ModifiableRootModel rootModel) throws ConfigurationException {
	ContentEntry contentEntry = doAddContentEntry(rootModel);
	if (contentEntry != null) {
		final List<Pair<String, String>> sourcePaths = getSourcePaths();

		if (sourcePaths != null) {
			for (final Pair<String, String> sourcePath : sourcePaths) {
				String first = sourcePath.first;
				new File(first).mkdirs();
				final VirtualFile sourceRoot = LocalFileSystem.getInstance().refreshAndFindFileByPath(FileUtil.toSystemIndependentName(first));
				if (sourceRoot != null) {
					contentEntry.addSourceFolder(sourceRoot, false, sourcePath.second);
				}
			}
		}
	}
}
 

@NotNull
@Override
protected LightProjectDescriptor getProjectDescriptor() {
    LanguageLevel languageLevel = LanguageLevel.JDK_1_8;
    return new DefaultLightProjectDescriptor() {
        @Override
        public Sdk getSdk() {
            String compilerOption = JpsJavaSdkType.complianceOption(languageLevel.toJavaVersion());
            return JavaSdk.getInstance().createJdk( "java " + compilerOption, BUILD_MOCK_JDK_DIRECTORY + compilerOption, false );
        }

        @Override
        public void configureModule(@NotNull Module module, @NotNull ModifiableRootModel model, @NotNull ContentEntry contentEntry) {
            model.getModuleExtension( LanguageLevelModuleExtension.class ).setLanguageLevel( languageLevel );
        }
    };
}
 

public void addLibraryOrderEntry(final Module module, final Library library) {
  Component parent = TargetAWT.to(WindowManager.getInstance().suggestParentWindow(module.getProject()));

  final ModuleEditor moduleEditor = myContext.myModulesConfigurator.getModuleEditor(module);
  LOG.assertTrue(moduleEditor != null, "Current module editor was not initialized");
  final ModifiableRootModel modelProxy = moduleEditor.getModifiableRootModelProxy();
  final OrderEntry[] entries = modelProxy.getOrderEntries();
  for (OrderEntry entry : entries) {
    if (entry instanceof LibraryOrderEntry && Comparing.strEqual(entry.getPresentableName(), library.getName())) {
      if (Messages.showYesNoDialog(parent,
                                   ProjectBundle.message("project.roots.replace.library.entry.message", entry.getPresentableName()),
                                   ProjectBundle.message("project.roots.replace.library.entry.title"),
                                   Messages.getInformationIcon()) == Messages.YES) {
        modelProxy.removeOrderEntry(entry);
        break;
      }
    }
  }
  modelProxy.addLibraryEntry(library);
  myContext.getDaemonAnalyzer().queueUpdate(new ModuleProjectStructureElement(myContext, module));
  myTree.repaint();
}
 

@Override
public void setupRootModel(ModifiableRootModel rootModel) throws ConfigurationException {
	ContentEntry contentEntry = doAddContentEntry(rootModel);
	if (contentEntry != null) {
		final List<Pair<String, String>> sourcePaths = getSourcePaths();

		if (sourcePaths != null) {
			for (final Pair<String, String> sourcePath : sourcePaths) {
				String first = sourcePath.first;
				new File(first).mkdirs();
				final VirtualFile sourceRoot = LocalFileSystem.getInstance().refreshAndFindFileByPath(FileUtil.toSystemIndependentName(first));
				if (sourceRoot != null) {
					contentEntry.addSourceFolder(sourceRoot, false, sourcePath.second);
				}
			}
		}
	}
}
 

@Override
public void moduleStateChanged() {
  myEntryToEditorMap.clear();
  myEditorsPanel.removeAll();

  final ModifiableRootModel model = getModel();
  if (model != null) {
    final ContentEntry[] contentEntries = model.getContentEntries();
    if (contentEntries.length > 0) {
      for (final ContentEntry contentEntry : contentEntries) {
        addContentEntryPanel(contentEntry);
      }
      selectContentEntry(contentEntries[0]);
    }
    else {
      selectContentEntry(null);
      myRootTreeEditor.setContentEntryEditor(null);
    }
  }

  if(myRootTreeEditor != null) {
    myRootTreeEditor.update();
  }
}
 

/**
 * Used to define the hierachy of the project definition
 *
 * @param rootModel
 * @throws ConfigurationException
 */
@Override
public void setupRootModel(final ModifiableRootModel rootModel) throws ConfigurationException {
    super.setupRootModel(rootModel);

    final Project project = rootModel.getProject();

    final VirtualFile root = createAndGetContentEntry();
    rootModel.addContentEntry(root);

    if (myJdk != null) {
        rootModel.setSdk(myJdk);
    } else {
        rootModel.inheritSdk();
    }

    createProjectFiles(rootModel, project);

}
 

@Override
public void updateProjectStructure(
    Project project,
    BlazeContext context,
    WorkspaceRoot workspaceRoot,
    ProjectViewSet projectViewSet,
    BlazeProjectData blazeProjectData,
    @Nullable BlazeProjectData oldBlazeProjectData,
    ModuleEditor moduleEditor,
    Module workspaceModule,
    ModifiableRootModel workspaceModifiableModel) {
  if (!blazeProjectData.getWorkspaceLanguageSettings().isLanguageActive(LanguageClass.GO)) {
    return;
  }
  for (Library lib : getGoLibraries(project)) {
    if (workspaceModifiableModel.findLibraryOrderEntry(lib) == null) {
      workspaceModifiableModel.addLibraryEntry(lib);
    }
  }
  PropertiesComponent.getInstance().setValue(DO_NOT_SHOW_NOTIFICATION_ABOUT_EMPTY_GOPATH, true);
}
 

@Override
public void updateProjectStructure(
    Project project,
    BlazeContext context,
    WorkspaceRoot workspaceRoot,
    ProjectViewSet projectViewSet,
    BlazeProjectData blazeProjectData,
    @Nullable BlazeProjectData oldBlazeProjectData,
    ModuleEditor moduleEditor,
    Module workspaceModule,
    ModifiableRootModel workspaceModifiableModel) {
  if (!blazeProjectData.getWorkspaceLanguageSettings().isLanguageActive(LanguageClass.SCALA)) {
    return;
  }
  for (Library library : ProjectLibraryTable.getInstance(project).getLibraries()) {
    // Convert the type of the SDK library to prevent the scala plugin from
    // showing the missing SDK notification.
    // TODO: use a canonical class in the SDK (e.g., scala.App) instead of the name?
    if (library.getName() != null && library.getName().startsWith("scala-library")) {
      ExistingLibraryEditor editor = new ExistingLibraryEditor(library, null);
      editor.setType(ScalaLibraryType.apply());
      editor.commit();
      return;
    }
  }
}
 

@Override
public Module createModule(String moduleName, ModuleType moduleType) {
  Module module = moduleModel.findModuleByName(moduleName);
  if (module == null) {
    File imlFile = new File(imlDirectory, moduleName + ModuleFileType.DOT_DEFAULT_EXTENSION);
    removeImlFile(imlFile);
    module = moduleModel.newModule(imlFile.getPath(), moduleType.getId());
    module.setOption(EXTERNAL_SYSTEM_ID_KEY, EXTERNAL_SYSTEM_ID_VALUE);
  }
  module.setOption(Module.ELEMENT_TYPE, moduleType.getId());

  ModifiableRootModel modifiableModel =
      ModuleRootManager.getInstance(module).getModifiableModel();
  modules.put(module.getName(), modifiableModel);
  modifiableModel.clear();
  modifiableModel.inheritSdk();
  CompilerModuleExtension compilerSettings =
      modifiableModel.getModuleExtension(CompilerModuleExtension.class);
  if (compilerSettings != null) {
    compilerSettings.inheritCompilerOutputPath(false);
  }

  return module;
}
 

@Override
public void updateProjectStructure(
    Project project,
    BlazeContext context,
    WorkspaceRoot workspaceRoot,
    ProjectViewSet projectViewSet,
    BlazeProjectData blazeProjectData,
    @Nullable BlazeProjectData oldBlazeProjectData,
    ModuleEditor moduleEditor,
    Module workspaceModule,
    ModifiableRootModel workspaceModifiableModel) {
  BlazeAndroidProjectStructureSyncer.updateProjectStructure(
      project,
      context,
      projectViewSet,
      blazeProjectData,
      moduleEditor,
      workspaceModule,
      workspaceModifiableModel,
      isAndroidWorkspace(blazeProjectData.getWorkspaceLanguageSettings()));
}
 

@NotNull
@Override
protected LightProjectDescriptor getProjectDescriptor() {
    LanguageLevel languageLevel = LanguageLevel.JDK_1_8;
    return new DefaultLightProjectDescriptor() {
        @Override
        public Sdk getSdk() {
            String compilerOption = JpsJavaSdkType.complianceOption(languageLevel.toJavaVersion());
            return JavaSdk.getInstance().createJdk( "java " + compilerOption, BUILD_MOCK_JDK_DIRECTORY + compilerOption, false );
        }

        @Override
        public void configureModule(@NotNull Module module, @NotNull ModifiableRootModel model, @NotNull ContentEntry contentEntry) {
            model.getModuleExtension( LanguageLevelModuleExtension.class ).setLanguageLevel( languageLevel );
        }
    };
}
 

@RequiredWriteAction
public static void multiCommit(ModifiableRootModel[] rootModels, ModifiableModuleModel moduleModel) {
  ApplicationManager.getApplication().assertWriteAccessAllowed();

  final List<RootModelImpl> modelsToCommit = getSortedChangedModels(rootModels, moduleModel);

  final List<ModifiableRootModel> modelsToDispose = new ArrayList<ModifiableRootModel>(Arrays.asList(rootModels));
  modelsToDispose.removeAll(modelsToCommit);

  ModuleManagerImpl.commitModelWithRunnable(moduleModel, new Runnable() {
    @Override
    public void run() {
      for (RootModelImpl rootModel : modelsToCommit) {
        rootModel.doCommitAndDispose(true);
      }

      for (ModifiableRootModel model : modelsToDispose) {
        model.dispose();
      }
    }
  });
}
 

@Override
public void setupRootModel(ModifiableRootModel rootModel) throws ConfigurationException {
    VirtualFile root = createAndGetContentEntry();
    rootModel.addContentEntry(root);
    if (myJdk != null) {
        rootModel.setSdk(myJdk);
    } else {
        rootModel.inheritSdk();
    }
    System.out.println("start to create folder in path");
}
 

@Override
public void setupRootModel(ModifiableRootModel modifiableRootModel) throws ConfigurationException {
    checkGaugeIsInstalled();
    super.setupRootModel(modifiableRootModel);
    gaugeInit(modifiableRootModel);
    new GaugeLibHelper(modifiableRootModel.getModule()).checkDeps();
}
 

private void setupCompilationSettings(Module module, ModifiableRootModel model) {
  Project project = module.getProject();
  for(VirtualFile root:model.getContentRoots()) {
    if(hasCompilationTarget(project, root.getPath(), myHxml)) {
      HaxeModuleSettings settings = HaxeModuleSettings.getInstance(module);
      settings.setBuildConfig(HaxeConfiguration.HXML.asBuildConfigValue());
      settings.setHxmlPath(getPath(root.getPath(), myHxml));
      //TODO: Proper implementation of running the output of every Haxe target.
      settings.setHaxeTarget(HaxeTarget.INTERP);
      break;
    }
  }
}
 

/**
 * Searches for excluded roots in given {@link Project}.
 *
 * @param project current project
 * @return list of excluded roots
 */
public static List<VirtualFile> getExcludedRoots(@NotNull Project project) {
    List<VirtualFile> roots = new ArrayList<>();
    ModuleManager manager = ModuleManager.getInstance(project);
    for (Module module : manager.getModules()) {
        ModifiableRootModel model = ModuleRootManager.getInstance(module).getModifiableModel();
        if (model.isDisposed()) {
            continue;
        }
        Collections.addAll(roots, model.getExcludeRoots());
        model.dispose();
    }
    return roots;
}
 

@After
public final void removeSourceFolder() {
  ApplicationManager.getApplication()
      .runWriteAction(
          () -> {
            final ModifiableRootModel model =
                ModuleRootManager.getInstance(testFixture.getModule()).getModifiableModel();
            ContentEntry contentEntry = model.getContentEntries()[0];
            contentEntry.removeSourceFolder(javaSourceRoot);
            model.commit();
          });
}
 

private void addLib(ProjectLib lib, ModifiableRootModel modifiableRootModel) {
    final Library library = modifiableRootModel.getModuleLibraryTable().createLibrary(lib.getLibName());
    final VirtualFile libDir = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(lib.getDir());
    if (libDir != null) {
        final Library.ModifiableModel libModel = library.getModifiableModel();
        libModel.addJarDirectory(libDir, true);
        libModel.commit();
    }
}
 

@Before
public final void addSourceFolder() {
  // create a source root so that the package prefixes are correct.
  VirtualFile pkgRoot = workspace.createDirectory(new WorkspacePath("java"));
  ApplicationManager.getApplication()
      .runWriteAction(
          () -> {
            final ModifiableRootModel model =
                ModuleRootManager.getInstance(testFixture.getModule()).getModifiableModel();
            ContentEntry contentEntry = model.getContentEntries()[0];
            javaSourceRoot = contentEntry.addSourceFolder(pkgRoot, true, "");
            model.commit();
          });

  BlazeProjectDataManager mockProjectDataManager =
      new MockBlazeProjectDataManager(MockBlazeProjectDataBuilder.builder(workspaceRoot).build());
  registerProjectService(BlazeProjectDataManager.class, mockProjectDataManager);
  registerProjectService(
      WorkspaceFileFinder.Provider.class, () -> file -> file.getPath().contains("test"));

  // required for IntelliJ to recognize annotations, JUnit version, etc.
  workspace.createPsiFile(
      new WorkspacePath("org/junit/runner/RunWith.java"),
      "package org.junit.runner;"
          + "public @interface RunWith {"
          + "    Class<? extends Runner> value();"
          + "}");
  workspace.createPsiFile(
      new WorkspacePath("org/junit/Test.java"),
      "package org.junit;",
      "public @interface Test {}");
  workspace.createPsiFile(
      new WorkspacePath("org/junit/runners/JUnit4.java"),
      "package org.junit.runners;",
      "public class JUnit4 {}");
}
 

protected ContentEntryEditor createContentEntryEditor(ContentEntry contentEntry) {
  return new ContentEntryEditor(contentEntry) {
    @Override
    protected ModifiableRootModel getModel() {
      return ContentEntriesEditor.this.getModel();
    }
  };
}