import com.intellij.ide.util.projectWizard.importSources.DetectedProjectRoot; //导入依赖的package包/类
protected void importFromSources(File dir) {
  myRootDir = dir;
  try {
    myProject = doCreateProject(getIprFile());
    myBuilder.setBaseProjectPath(dir.getAbsolutePath());
    List<DetectedRootData> list = RootDetectionProcessor.detectRoots(dir);
    MultiMap<ProjectStructureDetector,DetectedProjectRoot> map = RootDetectionProcessor.createRootsMap(list);
    myBuilder.setupProjectStructure(map);
    for (ProjectStructureDetector detector : map.keySet()) {
      List<ModuleWizardStep> steps = detector.createWizardSteps(myBuilder, myBuilder.getProjectDescriptor(detector), EmptyIcon.ICON_16);
      for (ModuleWizardStep step : steps) {
        if (step instanceof AbstractStepWithProgress<?>) {
          performStep((AbstractStepWithProgress<?>)step);
        }
      }
    }
    myBuilder.commit(myProject, null, ModulesProvider.EMPTY_MODULES_PROVIDER);
  }
  catch (Exception e) {
    throw new RuntimeException(e);
  }
}
 

import com.intellij.ide.util.projectWizard.importSources.DetectedProjectRoot; //导入依赖的package包/类
public Map<ProjectStructureDetector, List<DetectedProjectRoot>> runDetectors() {
  if (!myBaseDir.isDirectory()) {
    return Collections.emptyMap();
  }

  BitSet enabledDetectors = new BitSet(myDetectors.length);
  enabledDetectors.set(0, myDetectors.length);
  for (int i = 0; i < myDetectors.length; i++) {
    myDetectedRoots[i] = new ArrayList<DetectedProjectRoot>();
  }
  processRecursively(myBaseDir, enabledDetectors);

  final Map<ProjectStructureDetector, List<DetectedProjectRoot>> result = new LinkedHashMap<ProjectStructureDetector, List<DetectedProjectRoot>>();
  for (int i = 0; i < myDetectors.length; i++) {
    if (!myDetectedRoots[i].isEmpty()) {
      result.put(myDetectors[i], myDetectedRoots[i]);
    }
  }
  return result;
}
 

import com.intellij.ide.util.projectWizard.importSources.DetectedProjectRoot; //导入依赖的package包/类
private static void removeIncompatibleRoots(DetectedProjectRoot root, Map<File, DetectedRootData> rootData) {
  DetectedRootData[] allRoots = rootData.values().toArray(new DetectedRootData[rootData.values().size()]);
  for (DetectedRootData child : allRoots) {
    final File childDirectory = child.getDirectory();
    if (FileUtil.isAncestor(root.getDirectory(), childDirectory, true)) {
      for (DetectedProjectRoot projectRoot : child.getAllRoots()) {
        if (!root.canContainRoot(projectRoot)) {
          child.removeRoot(projectRoot);
        }
      }
      if (child.isEmpty()) {
        rootData.remove(childDirectory);
      }
    }
  }
}
 

import com.intellij.ide.util.projectWizard.importSources.DetectedProjectRoot; //导入依赖的package包/类
public void setElements(List<? extends DetectedRootData> roots) {
  Set<String> rootTypes = new HashSet<String>();
  for (DetectedRootData root : roots) {
    for (DetectedProjectRoot projectRoot : root.getAllRoots()) {
      rootTypes.add(projectRoot.getRootTypeName());
    }
  }
  myModel.setColumnInfos(new ColumnInfo[]{myIncludedColumn, ROOT_COLUMN, ROOT_TYPE_COLUMN});
  int max = 0;
  for (String rootType : rootTypes) {
    max = Math.max(max, myTable.getFontMetrics(myTable.getFont()).stringWidth(rootType));
  }
  final TableColumn column = myTable.getColumnModel().getColumn(2);
  int width = max + 20;//add space for combobox button
  column.setPreferredWidth(width);
  column.setMaxWidth(width);
  myTable.updateColumnSizes();
  List<DetectedRootData> sortedRoots = new ArrayList<DetectedRootData>(roots);
  Collections.sort(sortedRoots, new Comparator<DetectedRootData>() {
    @Override
    public int compare(DetectedRootData o1, DetectedRootData o2) {
      return o1.getDirectory().compareTo(o2.getDirectory());
    }
  });
  myModel.setItems(sortedRoots);
}
 

import com.intellij.ide.util.projectWizard.importSources.DetectedProjectRoot; //导入依赖的package包/类
public DetectedProjectRoot addRoot(ProjectStructureDetector detector, DetectedProjectRoot root) {
  for (Map.Entry<DetectedProjectRoot, Collection<ProjectStructureDetector>> entry : myRoots.entrySet()) {
    final DetectedProjectRoot oldRoot = entry.getKey();
    final DetectedProjectRoot combined = oldRoot.combineWith(root);
    if (combined != null) {
      myRoots.remove(oldRoot);
      final Set<ProjectStructureDetector> values = new HashSet<ProjectStructureDetector>(entry.getValue());
      values.add(detector);
      myRoots.put(combined, values);
      if (mySelectedRoot == oldRoot) {
        mySelectedRoot = combined;
      }
      return combined;
    }
  }
  myRoots.putValue(root, detector);
  return root;
}
 

import com.intellij.ide.util.projectWizard.importSources.DetectedProjectRoot; //导入依赖的package包/类
@NotNull
@Override
public DirectoryProcessingResult detectRoots(@NotNull File dir,
                                             @NotNull File[] children,
                                             @NotNull File base,
                                             @NotNull List<DetectedProjectRoot> result) {
  LOG.info("Detecting roots under "  + dir);
  for (File child : children) {
    final String name = child.getName();
    if (FileUtilRt.extensionEquals(name, "py")) {
      LOG.info("Found Python file " + child.getPath());
      result.add(new DetectedContentRoot(dir, "Python", PythonModuleTypeBase.getInstance(), WebModuleType.getInstance()));
      return DirectoryProcessingResult.SKIP_CHILDREN;
    }
    if ("node_modules".equals(name)) {
      return DirectoryProcessingResult.SKIP_CHILDREN;
    }
  }
  return DirectoryProcessingResult.PROCESS_CHILDREN;
}
 

import com.intellij.ide.util.projectWizard.importSources.DetectedProjectRoot; //导入依赖的package包/类
@NotNull
@Override
public DirectoryProcessingResult detectRoots(@NotNull File dir,
                                             @NotNull File[] children,
                                             @NotNull File base,
                                             @NotNull List<DetectedProjectRoot> result) {
  detectApplicationRoot(dir, result);

  for (DetectedProjectRoot projectRoot : result) {
    if ((projectRoot instanceof CloudGitProjectRoot) && FileUtil.isAncestor(projectRoot.getDirectory(), dir, true)) {
      return detectJavaRoots(((CloudGitProjectRoot)projectRoot).getJavaSourceRootTypeName(), dir, children, base, result);
    }
  }

  return DirectoryProcessingResult.PROCESS_CHILDREN;
}
 

import com.intellij.ide.util.projectWizard.importSources.DetectedProjectRoot; //导入依赖的package包/类
private static void detectApplicationRoot(@NotNull File dir, @NotNull List<DetectedProjectRoot> result) {
  VirtualFile repositoryRoot = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(dir);
  if (repositoryRoot == null) {
    return;
  }
  if (GitUtil.findGitDir(repositoryRoot) == null) {
    return;
  }

  Project project = ProjectManager.getInstance().getDefaultProject();
  GitRepository repository
    = GitRepositoryImpl.getLightInstance(repositoryRoot, project, ServiceManager.getService(project, GitPlatformFacade.class), project);
  repository.update();

  for (CloudGitDeploymentDetector deploymentDetector : CloudGitDeploymentDetector.EP_NAME.getExtensions()) {
    String applicationName = deploymentDetector.getFirstApplicationName(repository);
    if (applicationName != null) {
      result.add(new CloudGitProjectRoot(deploymentDetector, dir, repositoryRoot, applicationName));
    }
  }
}
 

import com.intellij.ide.util.projectWizard.importSources.DetectedProjectRoot; //导入依赖的package包/类
public void iterate() {
  Collection<DetectedProjectRoot> roots = myBuilder.getProjectRoots(myStructureDetector);

  CloudGitDeploymentDetector point = getDeploymentDetector();
  String projectRootTypeName = CloudGitProjectRoot.getProjectRootTypeName(point);
  String javaSourceRootTypeName = CloudGitProjectRoot.getJavaSourceRootTypeName(point);

  for (DetectedProjectRoot root : roots) {
    if ((root instanceof CloudGitProjectRoot) && root.getRootTypeName().equals(projectRootTypeName)) {
      processProjectRoot((CloudGitProjectRoot)root);
    }
    else if ((root instanceof DetectedSourceRoot) && root.getRootTypeName().equals(javaSourceRootTypeName)) {
      processJavaSourceRoot((DetectedSourceRoot)root);
    }
  }
}
 

import com.intellij.ide.util.projectWizard.importSources.DetectedProjectRoot; //导入依赖的package包/类
@NotNull
@Override
public DirectoryProcessingResult detectRoots(@NotNull File dir,
                                             @NotNull File[] children,
                                             @NotNull File base,
                                             @NotNull List<DetectedProjectRoot> result) {
    Pattern pattern = Pattern.compile(".*\\." + SquirrelFileType.EXTENSION);
    List<File> filesByMask = FileUtil.findFilesByMask(pattern, base);
    if (!filesByMask.isEmpty()) {
        result.add(new DetectedProjectRoot(dir) {
            @NotNull
            @Override
            public String getRootTypeName() {
                return SquirrelModuleType.MODULE_TYPE_ID;
            }
        });
    }
    return DirectoryProcessingResult.SKIP_CHILDREN;
}
 

import com.intellij.ide.util.projectWizard.importSources.DetectedProjectRoot; //导入依赖的package包/类
/**
     * {@inheritDoc}
     * <p>
     * We determine that a directory is the root of a Spoofax project when it
     * has a file `editor/*.main.esv`.
     */
    @Override
    public DirectoryProcessingResult detectRoots(
            final File dir,
            final File[] children,
            final File base,
            final List<DetectedProjectRoot> result) {

        this.logger.info("Detecting Spoofax project in subdirectory {} of base {}", dir, base);

        if(this.configService.available(this.resourceService.resolve(dir))) {
            this.logger.info("Detected Spoofax project in {}", base);
//                        result.add(new DetectedContentRoot(base, "Spoofax", this.moduleType, JavaModuleType.getModuleType()));
            result.add(new MetaborgProjectRoot(base));
            return DirectoryProcessingResult.SKIP_CHILDREN;
        }

        return DirectoryProcessingResult.PROCESS_CHILDREN;
    }
 

import com.intellij.ide.util.projectWizard.importSources.DetectedProjectRoot; //导入依赖的package包/类
public final void setRoots(final List<File> contentRoots, final List<? extends DetectedProjectRoot> sourceRoots, final Set<String> ignoredNames) {
  myModules = null;
  myLibraries = null;

  myEntryPointRoots.clear();
  myEntryPointRoots.addAll(contentRoots);

  mySourceRoots.clear();
  mySourceRoots.addAll(sourceRoots);

  myIgnoredNames.clear();
  myIgnoredNames.addAll(ignoredNames);

  myJarToPackagesMap.clear();
  myInterner.clear();
}
 

import com.intellij.ide.util.projectWizard.importSources.DetectedProjectRoot; //导入依赖的package包/类
private static File appendContentRoot(final ModuleDescriptor module, final File contentRoot) {
  final Set<File> moduleRoots = module.getContentRoots();
  for (File moduleRoot : moduleRoots) {
    if (FileUtil.isAncestor(moduleRoot, contentRoot, false)) {
      return moduleRoot; // no need to include a separate root
    }
    if (FileUtil.isAncestor(contentRoot, moduleRoot, true)) {
      final Collection<DetectedProjectRoot> currentSources = module.getSourceRoots(moduleRoot);
      module.removeContentRoot(moduleRoot);
      module.addContentRoot(contentRoot);
      for (DetectedProjectRoot source : currentSources) {
        module.addSourceRoot(contentRoot, source);
      }
      return contentRoot; // no need to include a separate root
    }
  }
  module.addContentRoot(contentRoot);
  return contentRoot;
}
 

import com.intellij.ide.util.projectWizard.importSources.DetectedProjectRoot; //导入依赖的package包/类
private static void removeIncompatibleRoots(DetectedProjectRoot root, Map<File, DetectedRootData> rootData) {
  DetectedRootData[] allRoots = rootData.values().toArray(new DetectedRootData[rootData.values().size()]);
  for (DetectedRootData child : allRoots) {
    final File childDirectory = child.getDirectory();
    if (FileUtil.isAncestor(root.getDirectory(), childDirectory, true)) {
      for (DetectedProjectRoot projectRoot : child.getAllRoots()) {
        if (!root.canContainRoot(projectRoot)) {
          child.removeRoot(projectRoot);
        }
      }
      if (child.getAllRoots().length == 0) {
        rootData.remove(childDirectory);
      }
    }
  }
}
 

import com.intellij.ide.util.projectWizard.importSources.DetectedProjectRoot; //导入依赖的package包/类
public Map<ProjectStructureDetector, List<DetectedProjectRoot>> findRoots() {
  if (!myBaseDir.isDirectory()) {
    return Collections.emptyMap();
  }

  BitSet enabledDetectors = new BitSet(myDetectors.length);
  enabledDetectors.set(0, myDetectors.length);
  for (int i = 0; i < myDetectors.length; i++) {
    myDetectedRoots[i] = new ArrayList<DetectedProjectRoot>();
  }
  processRecursively(myBaseDir, enabledDetectors);

  final Map<ProjectStructureDetector, List<DetectedProjectRoot>> result = new LinkedHashMap<ProjectStructureDetector, List<DetectedProjectRoot>>();
  for (int i = 0; i < myDetectors.length; i++) {
    if (!myDetectedRoots[i].isEmpty()) {
      result.put(myDetectors[i], myDetectedRoots[i]);
    }
  }
  return result;
}
 

import com.intellij.ide.util.projectWizard.importSources.DetectedProjectRoot; //导入依赖的package包/类
@NotNull
@Override
public DirectoryProcessingResult detectRoots(@NotNull File dir,
                                             @NotNull File[] children,
                                             @NotNull File base,
                                             @NotNull List<DetectedProjectRoot> result) {
  for (File child : children) {
    if (child.isFile() && child.getName().endsWith(HaxeFileType.DEFAULT_EXTENSION)) {
      Pair<File, String> root =
        CommonSourceRootDetectionUtil.IO_FILE.suggestRootForFileWithPackageStatement(child, base, PACKAGE_NAME_FETCHER, false);
      if (root != null) {
        result.add(new HaxeModuleSourceRoot(root.getFirst()));
        return DirectoryProcessingResult.skipChildrenAndParentsUpTo(root.getFirst());
      }
      else {
        return DirectoryProcessingResult.SKIP_CHILDREN;
      }
    }
  }
  return DirectoryProcessingResult.PROCESS_CHILDREN;
}
 

import com.intellij.ide.util.projectWizard.importSources.DetectedProjectRoot; //导入依赖的package包/类
private void doTest(String... expected) {
  final String dirPath = FileUtil.toSystemDependentName(HaxeTestUtils.BASE_TEST_DATA_PATH + "/rootDetection/") + getTestName(true);
  final File dir = new File(dirPath);
  assertTrue(dir.isDirectory());
  final HaxeProjectStructureDetector haxeProjectStructureDetector = new HaxeProjectStructureDetector();
  final ProjectStructureDetector[] detector = new ProjectStructureDetector[]{haxeProjectStructureDetector};
  final RootDetectionProcessor detectionProcessor = new RootDetectionProcessor(
    dir,detector
  );
  // TODO:
  final List<DetectedProjectRoot> detected;//= detectionProcessor.findRoots().get(haxeProjectStructureDetector);
  Map<ProjectStructureDetector, List<DetectedProjectRoot>> detectorListMap = detectionProcessor.runDetectors();
  detected = detectorListMap.get(haxeProjectStructureDetector);
  assertNotNull(detected);
  final Set<String> actual = new THashSet<String>();
  for (DetectedProjectRoot projectRoot : detected) {
    final String relativePath = FileUtil.getRelativePath(dir, projectRoot.getDirectory());
    assertNotNull(relativePath);
    actual.add(FileUtil.toSystemIndependentName(relativePath));
  }
  assertSameElements(actual, expected);
}
 

import com.intellij.ide.util.projectWizard.importSources.DetectedProjectRoot; //导入依赖的package包/类
/**
 * For debug purposes only
 */
public String toString() {
  @NonNls final StringBuilder builder = new StringBuilder();
  builder.append("[Module: ").append(getContentRoots()).append(" | ");
  for (DetectedProjectRoot sourceRoot : getSourceRoots()) {
    builder.append(sourceRoot.getDirectory().getName()).append(",");
  }
  builder.append("]");
  return builder.toString();
}
 

import com.intellij.ide.util.projectWizard.importSources.DetectedProjectRoot; //导入依赖的package包/类
private void buildModuleDependencies(final Map<File, ModuleDescriptor> contentRootToModules) {
  final Set<File> moduleContentRoots = contentRootToModules.keySet();

  for (File contentRoot : moduleContentRoots) {
    final ModuleDescriptor checkedModule = contentRootToModules.get(contentRoot);
    myProgress.setText2("Building library dependencies for module " + checkedModule.getName());
    buildJarDependencies(checkedModule);

    myProgress.setText2("Building module dependencies for module " + checkedModule.getName());
    for (File aContentRoot : moduleContentRoots) {
      final ModuleDescriptor aModule = contentRootToModules.get(aContentRoot);
      if (checkedModule.equals(aModule)) {
        continue; // avoid self-dependencies
      }
      final Collection<? extends DetectedProjectRoot> aModuleRoots = aModule.getSourceRoots();
      checkModules:
      for (DetectedProjectRoot srcRoot: checkedModule.getSourceRoots()) {
        final Set<String> referencedBySourceRoot = mySourceRootToReferencedPackagesMap.get(srcRoot.getDirectory());
        for (DetectedProjectRoot aSourceRoot : aModuleRoots) {
          if (ContainerUtil.intersects(referencedBySourceRoot, mySourceRootToPackagesMap.get(aSourceRoot.getDirectory()))) {
            checkedModule.addDependencyOn(aModule);
            break checkModules;
          }
        }
      }
    }
  }
}
 

import com.intellij.ide.util.projectWizard.importSources.DetectedProjectRoot; //导入依赖的package包/类
private void buildJarDependencies(final ModuleDescriptor module) {
  for (File jarFile : myJarToPackagesMap.keySet()) {
    final Set<String> jarPackages = myJarToPackagesMap.get(jarFile);
    for (DetectedProjectRoot srcRoot : module.getSourceRoots()) {
      if (ContainerUtil.intersects(mySourceRootToReferencedPackagesMap.get(srcRoot.getDirectory()), jarPackages)) {
        module.addLibraryFile(jarFile);
        break;
      }
    }
  }
}