public void testHandlingDirectoryWithPomFileDeletion() throws Exception {
    importProject(
        "<groupId>test</groupId>"
            + "<artifactId>project</artifactId>"
            + "<packaging>pom</packaging>"
            + "<version>1</version>");

    createModulePom(
        "dir/module",
        "<groupId>test</groupId>" + "<artifactId>module</artifactId>" + "<version>1</version>");
    createProjectPom(
        "<groupId>test</groupId>"
            + "<artifactId>project</artifactId>"
            + "<packaging>pom</packaging>"
            + "<version>1</version>"
            + "<modules>"
            + "  <module>dir/module</module>"
            + "</modules>");
    waitForReadingCompletion();

    assertEquals(2, MavenProjectsManager.getInstance(myProject).getProjects().size());

    final VirtualFile dir = myProjectRoot.findChild("dir");
    new WriteCommandAction.Simple(myProject) {
      @Override
      protected void run() throws Throwable {
        dir.delete(null);
      }
    }.execute().throwException();

    waitForReadingCompletion();

    assertEquals(1, MavenProjectsManager.getInstance(myProject).getProjects().size());
  }
示例#2
0
 protected void readProjects(VirtualFile... files) {
   List<MavenProject> projects = new ArrayList<MavenProject>();
   for (VirtualFile each : files) {
     projects.add(myProjectsManager.findProject(each));
   }
   myProjectsManager.forceUpdateProjects(projects);
   waitForReadingCompletion();
 }
示例#3
0
 protected void resolveFoldersAndImport() {
   myProjectsManager.scheduleFoldersResolveForAllProjects();
   myProjectsManager.waitForFoldersResolvingCompletion();
   UIUtil.invokeAndWaitIfNeeded(
       new Runnable() {
         @Override
         public void run() {
           myProjectsManager.performScheduledImportInTests();
         }
       });
 }
  private static <T> boolean processParentProjectFile(
      MavenDomProjectModel projectDom,
      final Processor<T> processor,
      final Project project,
      final Function<? super MavenDomProfile, T> domProfileFunction,
      final Function<? super MavenDomProjectModel, T> projectDomFunction,
      final Set<MavenDomProjectModel> processed) {
    Boolean aBoolean =
        new DomParentProjectFileProcessor<Boolean>(MavenProjectsManager.getInstance(project)) {
          protected Boolean doProcessParent(VirtualFile parentFile) {
            MavenDomProjectModel parentProjectDom =
                MavenDomUtil.getMavenDomProjectModel(project, parentFile);
            if (parentProjectDom == null) return false;

            return MavenDomProjectProcessorUtils.process(
                parentProjectDom,
                processor,
                project,
                domProfileFunction,
                projectDomFunction,
                processed);
          }
        }.process(projectDom);

    return aBoolean == null ? false : aBoolean.booleanValue();
  }
 @NotNull
 public MavenWorkspaceSettings getState() {
   MavenExplicitProfiles profiles =
       MavenProjectsManager.getInstance(myProject).getExplicitProfiles();
   mySettings.setEnabledProfiles(profiles.getEnabledProfiles());
   mySettings.setDisabledProfiles(profiles.getDisabledProfiles());
   return mySettings;
 }
示例#6
0
  protected MavenArtifactDownloader.DownloadResult downloadArtifacts(
      Collection<MavenProject> projects, List<MavenArtifact> artifacts) {
    final MavenArtifactDownloader.DownloadResult[] unresolved =
        new MavenArtifactDownloader.DownloadResult[1];

    AsyncResult<MavenArtifactDownloader.DownloadResult> result =
        new AsyncResult<MavenArtifactDownloader.DownloadResult>();
    result.doWhenDone(
        new Consumer<MavenArtifactDownloader.DownloadResult>() {
          @Override
          public void consume(MavenArtifactDownloader.DownloadResult unresolvedArtifacts) {
            unresolved[0] = unresolvedArtifacts;
          }
        });

    myProjectsManager.scheduleArtifactsDownloading(projects, artifacts, true, true, result);
    myProjectsManager.waitForArtifactsDownloadingCompletion();

    return unresolved[0];
  }
示例#7
0
 @Override
 protected void setUpInWriteAction() throws Exception {
   super.setUpInWriteAction();
   myProjectsManager = MavenProjectsManager.getInstance(myProject);
   removeFromLocalRepository("test");
   if (useJps()) {
     CompilerTestUtil.enableExternalCompiler(myProject);
   } else {
     CompilerTestUtil.disableExternalCompiler(myProject);
   }
 }
示例#8
0
 @Override
 protected void tearDown() throws Exception {
   Messages.setTestDialog(TestDialog.DEFAULT);
   myProjectsManager.projectClosed();
   removeFromLocalRepository("test");
   if (useJps()) {
     CompilerTestUtil.disableExternalCompiler(myProject);
     FileUtil.delete(BuildManager.getInstance().getBuildSystemDirectory());
   }
   super.tearDown();
 }
  @Nullable
  public static MavenDomProjectModel findParent(
      @NotNull MavenDomParent mavenDomParent, Project project) {
    if (!DomUtil.hasXml(mavenDomParent)) return null;

    MavenId id =
        new MavenId(
            mavenDomParent.getGroupId().getStringValue(),
            mavenDomParent.getArtifactId().getStringValue(),
            mavenDomParent.getVersion().getStringValue());
    MavenProject mavenProject = MavenProjectsManager.getInstance(project).findProject(id);

    return mavenProject != null
        ? MavenDomUtil.getMavenDomProjectModel(project, mavenProject.getFile())
        : null;
  }
 private static void collectChildrenProjects(
     @NotNull final MavenDomProjectModel model, @NotNull Set<MavenDomProjectModel> models) {
   MavenProject mavenProject = MavenDomUtil.findProject(model);
   if (mavenProject != null) {
     final Project project = model.getManager().getProject();
     for (MavenProject inheritor :
         MavenProjectsManager.getInstance(project).findInheritors(mavenProject)) {
       MavenDomProjectModel inheritorProjectModel =
           MavenDomUtil.getMavenDomProjectModel(project, inheritor.getFile());
       if (inheritorProjectModel != null && !models.contains(inheritorProjectModel)) {
         models.add(inheritorProjectModel);
         collectChildrenProjects(inheritorProjectModel, models);
       }
     }
   }
 }
    @Nullable
    public T process(@NotNull MavenDomProjectModel projectDom) {
      MavenDomParent parent = projectDom.getMavenParent();
      MavenParentDesc parentDesc = null;
      if (DomUtil.hasXml(parent)) {
        String parentGroupId = parent.getGroupId().getStringValue();
        String parentArtifactId = parent.getArtifactId().getStringValue();
        String parentVersion = parent.getVersion().getStringValue();
        String parentRelativePath = parent.getRelativePath().getStringValue();
        if (StringUtil.isEmptyOrSpaces(parentRelativePath)) parentRelativePath = "../pom.xml";
        MavenId parentId = new MavenId(parentGroupId, parentArtifactId, parentVersion);
        parentDesc = new MavenParentDesc(parentId, parentRelativePath);
      }

      return process(
          myManager.getGeneralSettings(), MavenDomUtil.getVirtualFile(projectDom), parentDesc);
    }
  private static <T> boolean processSettingsXml(
      @Nullable MavenProject mavenProject,
      @NotNull Processor<T> processor,
      @NotNull Project project,
      Function<? super MavenDomProfile, T> domProfileFunction) {
    MavenGeneralSettings settings = MavenProjectsManager.getInstance(project).getGeneralSettings();

    for (VirtualFile each : settings.getEffectiveSettingsFiles()) {
      MavenDomSettingsModel settingsDom =
          MavenDomUtil.getMavenDomModel(project, each, MavenDomSettingsModel.class);
      if (settingsDom == null) continue;

      if (processProfiles(settingsDom.getProfiles(), mavenProject, processor, domProfileFunction))
        return true;
    }
    return false;
  }
  public static void processChildrenRecursively(
      @Nullable MavenDomProjectModel model,
      @NotNull Processor<MavenDomProjectModel> processor,
      @NotNull Project project,
      @NotNull Set<MavenDomProjectModel> processedModels,
      boolean strict) {
    if (model != null && !processedModels.contains(model)) {
      processedModels.add(model);

      if (strict && processor.process(model)) return;

      MavenProject mavenProject = MavenDomUtil.findProject(model);
      if (mavenProject != null) {
        for (MavenProject childProject :
            MavenProjectsManager.getInstance(project).findInheritors(mavenProject)) {
          MavenDomProjectModel childProjectModel =
              MavenDomUtil.getMavenDomProjectModel(project, childProject.getFile());

          processChildrenRecursively(childProjectModel, processor, project, processedModels, true);
        }
      }
    }
  }
示例#14
0
 protected void scheduleResolveAll() {
   myProjectsManager.scheduleResolveAllInTests();
 }
示例#15
0
 protected void readProjects(List<VirtualFile> files, String... profiles) {
   myProjectsManager.resetManagedFilesAndProfilesInTests(files, Arrays.asList(profiles));
   waitForReadingCompletion();
 }
示例#16
0
 protected void updateProjectsAndImport(VirtualFile... files) {
   readProjects(files);
   myProjectsManager.performScheduledImportInTests();
 }
示例#17
0
 protected void performPostImportTasks() {
   myProjectsManager.waitForPostImportTasksCompletion();
 }
示例#18
0
 protected void initProjectsManager(boolean enableEventHandling) {
   myProjectsManager.initForTests();
   myProjectsTree = myProjectsManager.getProjectsTreeForTests();
   if (enableEventHandling) myProjectsManager.listenForExternalChanges();
 }
示例#19
0
 protected void downloadArtifacts() {
   downloadArtifacts(myProjectsManager.getProjects(), null);
 }
示例#20
0
 protected void resolvePlugins() {
   myProjectsManager.waitForPluginsResolvingCompletion();
 }
 protected VirtualFile findManagedFile(@NotNull MavenId id) {
   MavenProject project = myManager.findProject(id);
   return project == null ? null : project.getFile();
 }
示例#22
0
 protected void readProjects() {
   readProjects(myProjectsManager.getProjectsFiles());
 }