com.intellij.ide.util.importProject.ProjectDescriptor Java Examples

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 setupProjectStructure(@NotNull Collection<DetectedProjectRoot> roots,
                                  @NotNull ProjectDescriptor projectDescriptor,
                                  @NotNull ProjectFromSourcesBuilder builder) {
  final List<ModuleDescriptor> modules = new ArrayList<>();
  for (DetectedProjectRoot root : roots) {
    modules.add(new ModuleDescriptor(root.getDirectory(), FlutterModuleUtils.getFlutterModuleType(), Collections.emptyList()));
  }

  projectDescriptor.setModules(modules);
  builder.setupModulesByContentRoots(projectDescriptor, roots);
}
 

@Override
public void setupProjectStructure(@NotNull Collection<DetectedProjectRoot> roots,
                                  @NotNull ProjectDescriptor projectDescriptor,
                                  @NotNull ProjectFromSourcesBuilder builder) {
  final List<ModuleDescriptor> modules = new ArrayList<>();
  for (DetectedProjectRoot root : roots) {
    modules.add(new ModuleDescriptor(root.getDirectory(), FlutterModuleUtils.getFlutterModuleType(), Collections.emptyList()));
  }

  projectDescriptor.setModules(modules);
  builder.setupModulesByContentRoots(projectDescriptor, roots);
}
 

/**
 * Creates ProjectDescriptor so project can be build from it's info.
 *
 * @param path project root dir
 * @param ignoredNames ie. compile output path
 * @return ProjectDescriptor
 */
public static ProjectDescriptor create(String path, Set<String> ignoredNames) {
    logger.info("Starting to create Project Descriptor in JavaProjectDescriptor.");

    logger.info("Initializing ProjectDescriptor");
    File contentFile = new File(path);
    ProjectDescriptor projectDescriptor = new ProjectDescriptor();
    List<ModuleDescriptor> moduleList = new ArrayList<>();
    List<LibraryDescriptor> libraryList = new ArrayList<>();
    projectDescriptor.setModules(moduleList);
    projectDescriptor.setLibraries(libraryList);

    logger.info("Searching for source files");
    //test file is considered as source file at this point
    Collection<JavaModuleSourceRoot> suggestedRoots =
            JavaSourceRootDetectionUtil.suggestRoots(contentFile);

    List<JavaModuleSourceRoot> rootList = new ArrayList<>();
    rootList.addAll(suggestedRoots);

    //Module insight creates module and library descriptors collecting data as long as roots are listed.
    ModuleInsight insight = new JavaModuleInsight(null, new HashSet<>(), new HashSet<>());
    List<File> entryPointRoots = new ArrayList<>();
    entryPointRoots.add(contentFile);

    logger.info("Setting up ModuleInsight roots");
    insight.setRoots(entryPointRoots, rootList, ignoredNames);

    logger.info("ModuleInsight scanning for modules and libraries");
    insight.scanLibraries();
    insight.scanModules();

    logger.info("Adding moduleDescriptors and LibraryDescriptors to projectDescriptor");
    libraryList.addAll(insight.getSuggestedLibraries());

    moduleList.addAll(insight.getSuggestedModules());

    logger.info("Ending to create Project Descriptor in JavaProjectDescriptor.");
    return projectDescriptor;
}
 

@Override
public List<ModuleWizardStep> createWizardSteps(ProjectFromSourcesBuilder builder, ProjectDescriptor projectDescriptor, Icon stepIcon) {
  HaxeSdkType type = HaxeSdkType.getInstance();
  type.ensureSdk();
  WizardContext wizardContext = builder.getContext();
  HaxeProjectConfigurationUpdater projectUpdater = new HaxeProjectConfigurationUpdater(wizardContext.getProjectFileDirectory());
  ((ProjectFromSourcesBuilderImpl)builder).addConfigurationUpdater(projectUpdater);
  HaxeModuleInsight moduleInsight = new HaxeModuleInsight(new DelegatingProgressIndicator(), builder);
  final List<ModuleWizardStep> steps = new ArrayList<>();
  steps.add(new HaxeLibrariesDetectionStep(builder, moduleInsight, projectUpdater));
  steps.add(new ModulesDetectionStep(this, builder, projectDescriptor, moduleInsight, stepIcon, "reference.dialogs.new.project.fromCode.page2"));
  steps.add(new ProjectJdkForModuleStep(wizardContext, type));
  steps.add(new HaxeHxmlDetectionStep(builder, projectUpdater));
  return steps;
}
 

private static void setupRootModel(
        ProjectDescriptor projectDescriptor,
        final ModuleDescriptor descriptor,
        final ModifiableRootModel rootModel,
        final Map<LibraryDescriptor, Library> projectLibs) {
    final CompilerModuleExtension compilerModuleExtension =
            rootModel.getModuleExtension(CompilerModuleExtension.class);
    compilerModuleExtension.setExcludeOutput(true);
    rootModel.inheritSdk();

    //Module root model seems to store .iml files root dependencies. (src, test, lib)
    logger.info("Starting setupRootModel in ProjectFromSourcesBuilderImplModified");
    final Set<File> contentRoots = descriptor.getContentRoots();
    for (File contentRoot : contentRoots) {
        final LocalFileSystem lfs = LocalFileSystem.getInstance();
        VirtualFile moduleContentRoot =
                lfs.refreshAndFindFileByPath(
                        FileUtil.toSystemIndependentName(contentRoot.getPath()));
        if (moduleContentRoot != null) {
            final ContentEntry contentEntry = rootModel.addContentEntry(moduleContentRoot);
            final Collection<DetectedSourceRoot> sourceRoots =
                    descriptor.getSourceRoots(contentRoot);
            for (DetectedSourceRoot srcRoot : sourceRoots) {
                final String srcpath =
                        FileUtil.toSystemIndependentName(srcRoot.getDirectory().getPath());
                final VirtualFile sourceRoot = lfs.refreshAndFindFileByPath(srcpath);
                if (sourceRoot != null) {
                    contentEntry.addSourceFolder(
                            sourceRoot,
                            shouldBeTestRoot(srcRoot.getDirectory()),
                            getPackagePrefix(srcRoot));
                }
            }
        }
    }
    logger.info("Inherits compiler output path from project");
    compilerModuleExtension.inheritCompilerOutputPath(true);

    logger.info("Starting to create module level libraries");
    final LibraryTable moduleLibraryTable = rootModel.getModuleLibraryTable();
    for (LibraryDescriptor libDescriptor :
            ModuleInsight.getLibraryDependencies(
                    descriptor, projectDescriptor.getLibraries())) {
        final Library projectLib = projectLibs.get(libDescriptor);
        if (projectLib != null) {
            rootModel.addLibraryEntry(projectLib);
        } else {
            // add as module library
            final Collection<File> jars = libDescriptor.getJars();
            for (File file : jars) {
                Library library = moduleLibraryTable.createLibrary();
                Library.ModifiableModel modifiableModel = library.getModifiableModel();
                modifiableModel.addRoot(
                        VfsUtil.getUrlForLibraryRoot(file), OrderRootType.CLASSES);
                modifiableModel.commit();
            }
        }
    }
    logger.info("Ending setupRootModel in ProjectFromSourcesBuilderImplModified");
}