Ejemplo n.º 1
0
 /**
  * The same as {@link #getModuleOutputDirectory} but returns String. The method still returns a
  * non-null value if the output path is specified in Settings but does not exist on disk.
  */
 @Nullable
 public static String getModuleOutputPath(final Module module, boolean forTestClasses) {
   final String outPathUrl;
   final Application application = ApplicationManager.getApplication();
   final CompilerModuleExtension extension = CompilerModuleExtension.getInstance(module);
   if (forTestClasses) {
     if (application.isDispatchThread()) {
       final String url = extension.getCompilerOutputUrlForTests();
       outPathUrl = url != null ? url : extension.getCompilerOutputUrl();
     } else {
       outPathUrl =
           application.runReadAction(
               new Computable<String>() {
                 public String compute() {
                   final String url = extension.getCompilerOutputUrlForTests();
                   return url != null ? url : extension.getCompilerOutputUrl();
                 }
               });
     }
   } else { // for ordinary classes
     if (application.isDispatchThread()) {
       outPathUrl = extension.getCompilerOutputUrl();
     } else {
       outPathUrl =
           application.runReadAction(
               new Computable<String>() {
                 public String compute() {
                   return extension.getCompilerOutputUrl();
                 }
               });
     }
   }
   return outPathUrl != null ? VirtualFileManager.extractPath(outPathUrl) : null;
 }
Ejemplo n.º 2
0
  protected void assertModuleOutput(String moduleName, String output, String testOutput) {
    CompilerModuleExtension e = getCompilerExtension(moduleName);

    assertFalse(e.isCompilerOutputPathInherited());
    assertEquals(output, getAbsolutePath(e.getCompilerOutputUrl()));
    assertEquals(testOutput, getAbsolutePath(e.getCompilerOutputUrlForTests()));
  }
 protected static File getOutputDir(Module module) {
   CompilerModuleExtension extension = CompilerModuleExtension.getInstance(module);
   Assert.assertNotNull(extension);
   String outputUrl = extension.getCompilerOutputUrl();
   Assert.assertNotNull(
       "Output directory for module '" + module.getName() + "' isn't specified", outputUrl);
   return JpsPathUtil.urlToFile(outputUrl);
 }
 private void createOutputDirectories() {
   for (Module module : ModuleManager.getInstance(myProject).getModules()) {
     CompilerModuleExtension extension = CompilerModuleExtension.getInstance(module);
     if (extension != null) {
       createDirectoryIfDoesntExist(extension.getCompilerOutputUrl());
       createDirectoryIfDoesntExist(extension.getCompilerOutputUrlForTests());
     }
   }
 }
  @NotNull
  private Map<String, GradleModuleResourceConfiguration> generateAffectedGradleModulesConfiguration(
      @NotNull CompileContext context) {
    final Map<String, GradleModuleResourceConfiguration> affectedGradleModuleConfigurations =
        ContainerUtil.newTroveMap();

    //noinspection MismatchedQueryAndUpdateOfCollection
    final Map<String, ExternalProject> lazyExternalProjectMap =
        new FactoryMap<String, ExternalProject>() {
          @Nullable
          @Override
          protected ExternalProject create(String gradleProjectPath) {
            return myExternalProjectDataService.getRootExternalProject(
                GradleConstants.SYSTEM_ID, new File(gradleProjectPath));
          }
        };

    for (Module module : context.getCompileScope().getAffectedModules()) {
      if (!ExternalSystemApiUtil.isExternalSystemAwareModule(GradleConstants.SYSTEM_ID, module))
        continue;

      if (shouldBeBuiltByExternalSystem(module)) continue;

      final String gradleProjectPath =
          module.getOptionValue(ExternalSystemConstants.ROOT_PROJECT_PATH_KEY);
      assert gradleProjectPath != null;
      final ExternalProject externalRootProject = lazyExternalProjectMap.get(gradleProjectPath);
      if (externalRootProject == null) {
        context.addMessage(
            CompilerMessageCategory.ERROR,
            String.format(
                "Unable to make the module: %s, related gradle configuration was not found. "
                    + "Please, re-import the Gradle project and try again.",
                module.getName()),
            VfsUtilCore.pathToUrl(gradleProjectPath),
            -1,
            -1);
        continue;
      }

      ExternalProject externalProject =
          myExternalProjectDataService.findExternalProject(externalRootProject, module);
      if (externalProject == null) {
        LOG.warn("Unable to find config for module: " + module.getName());
        continue;
      }

      GradleModuleResourceConfiguration resourceConfig = new GradleModuleResourceConfiguration();
      resourceConfig.id =
          new ModuleVersion(
              externalProject.getGroup(), externalProject.getName(), externalProject.getVersion());
      resourceConfig.directory =
          FileUtil.toSystemIndependentName(externalProject.getProjectDir().getPath());

      final ExternalSourceSet mainSourcesSet = externalProject.getSourceSets().get("main");
      addResources(resourceConfig.resources, mainSourcesSet, ExternalSystemSourceType.RESOURCE);

      final ExternalSourceSet testSourcesSet = externalProject.getSourceSets().get("test");
      addResources(
          resourceConfig.testResources, testSourcesSet, ExternalSystemSourceType.TEST_RESOURCE);

      final CompilerModuleExtension compilerModuleExtension =
          CompilerModuleExtension.getInstance(module);
      if (compilerModuleExtension != null
          && compilerModuleExtension.isCompilerOutputPathInherited()) {
        String outputPath = VfsUtilCore.urlToPath(compilerModuleExtension.getCompilerOutputUrl());
        for (ResourceRootConfiguration resource : resourceConfig.resources) {
          resource.targetPath = outputPath;
        }

        String testOutputPath =
            VfsUtilCore.urlToPath(compilerModuleExtension.getCompilerOutputUrlForTests());
        for (ResourceRootConfiguration resource : resourceConfig.testResources) {
          resource.targetPath = testOutputPath;
        }
      }

      affectedGradleModuleConfigurations.put(module.getName(), resourceConfig);
    }

    return affectedGradleModuleConfigurations;
  }