@Nullable protected VirtualFile findClassFile(String className) { final CompilerModuleExtension extension = ModuleRootManager.getInstance(myModule).getModuleExtension(CompilerModuleExtension.class); //noinspection ConstantConditions return extension.getCompilerOutputPath().findChild(className + ".class"); }
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())); }
/** * 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; }
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 static String getOutput(Module module1, boolean test) { CompilerModuleExtension compilerModuleExtension = CompilerModuleExtension.getInstance(module1); assertNotNull(compilerModuleExtension); VirtualFile output = test ? compilerModuleExtension.getCompilerOutputPathForTests() : compilerModuleExtension.getCompilerOutputPath(); return getFSPath(output); }
private void createOutputDirectories() { for (Module module : ModuleManager.getInstance(myProject).getModules()) { CompilerModuleExtension extension = CompilerModuleExtension.getInstance(module); if (extension != null) { createDirectoryIfDoesntExist(extension.getCompilerOutputUrl()); createDirectoryIfDoesntExist(extension.getCompilerOutputUrlForTests()); } } }
public static void setCompilerOutputPath(Module module, String url, boolean forTests) { ModuleRootModificationUtil.updateModel( module, model -> { CompilerModuleExtension extension = model.getModuleExtension(CompilerModuleExtension.class); extension.inheritCompilerOutputPath(false); if (forTests) { extension.setCompilerOutputPathForTests(url); } else { extension.setCompilerOutputPath(url); } }); }
private static Iterable<String> getOutputPaths(Project project) { final Collection<String> paths = new LinkedHashSet<>(); final CompilerProjectExtension cpe = CompilerProjectExtension.getInstance(project); if (cpe != null && cpe.getCompilerOutput() != null) { paths.add(cpe.getCompilerOutput().getCanonicalPath()); } final Module[] modules = ModuleManager.getInstance(project).getModules(); for (Module module : modules) { final CompilerModuleExtension cme = CompilerModuleExtension.getInstance(module); if (cme != null && cme.getCompilerOutputPath() != null) { paths.add(cme.getCompilerOutputPath().getCanonicalPath()); } } return paths; }
private static void addRootsFromModule(Module module, Collection<String> pythonPathList) { // for Jython final CompilerModuleExtension extension = CompilerModuleExtension.getInstance(module); if (extension != null) { final VirtualFile path = extension.getCompilerOutputPath(); if (path != null) { pythonPathList.add(path.getPath()); } final VirtualFile pathForTests = extension.getCompilerOutputPathForTests(); if (pathForTests != null) { pythonPathList.add(pathForTests.getPath()); } } // additional paths from facets (f.e. buildout) final Facet[] facets = FacetManager.getInstance(module).getAllFacets(); for (Facet facet : facets) { if (facet instanceof PythonPathContributingFacet) { List<String> more_paths = ((PythonPathContributingFacet) facet).getAdditionalPythonPath(); if (more_paths != null) pythonPathList.addAll(more_paths); } } }
/** * @param module * @param forTestClasses true if directory for test sources, false - for sources. * @return a directory to which the sources (or test sources depending on the second partameter) * should be compiled. Null is returned if output directory is not specified or is not valid */ @Nullable public static VirtualFile getModuleOutputDirectory(final Module module, boolean forTestClasses) { final CompilerModuleExtension compilerModuleExtension = CompilerModuleExtension.getInstance(module); VirtualFile outPath; if (forTestClasses) { final VirtualFile path = compilerModuleExtension.getCompilerOutputPathForTests(); if (path != null) { outPath = path; } else { outPath = compilerModuleExtension.getCompilerOutputPath(); } } else { outPath = compilerModuleExtension.getCompilerOutputPath(); } if (outPath == null) { return null; } if (!outPath.isValid()) { LOG.info("Requested output path for module " + module.getName() + " is not valid"); return null; } return outPath; }
private static File jarModulesOutput( @NotNull Set<Module> modules, @Nullable Manifest manifest, final @Nullable String pluginXmlPath) throws IOException { File jarFile = FileUtil.createTempFile(TEMP_PREFIX, JAR_EXTENSION); jarFile.deleteOnExit(); ZipOutputStream jarPlugin = null; try { BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(jarFile)); jarPlugin = manifest != null ? new JarOutputStream(out, manifest) : new JarOutputStream(out); final ProgressIndicator progressIndicator = ProgressManager.getInstance().getProgressIndicator(); final Set<String> writtenItemRelativePaths = new HashSet<String>(); for (Module module : modules) { final VirtualFile compilerOutputPath = CompilerModuleExtension.getInstance(module).getCompilerOutputPath(); if (compilerOutputPath == null) continue; // pre-condition: output dirs for all modules are up-to-date ZipUtil.addDirToZipRecursively( jarPlugin, jarFile, new File(compilerOutputPath.getPath()), "", createFilter(progressIndicator, FileTypeManager.getInstance()), writtenItemRelativePaths); } if (pluginXmlPath != null) { ZipUtil.addFileToZip( jarPlugin, new File(pluginXmlPath), "/META-INF/plugin.xml", writtenItemRelativePaths, createFilter(progressIndicator, null)); } } finally { if (jarPlugin != null) jarPlugin.close(); } return jarFile; }
private CompilerModuleExtension getCompilerExtension(String module) { ModuleRootManager m = getRootManager(module); return CompilerModuleExtension.getInstance(m.getModule()); }
@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; }
private static void removeModuleOutput(Module module, List<VirtualFile> from) { final CompilerModuleExtension extension = ModuleRootManager.getInstance(module).getModuleExtension(CompilerModuleExtension.class); from.remove(extension.getCompilerOutputPath()); from.remove(extension.getCompilerOutputPathForTests()); }
public static void setOutputUrl(ModifiableRootModel rootModel, String path) { final CompilerModuleExtension compilerModuleExtension = rootModel.getModuleExtension(CompilerModuleExtension.class); compilerModuleExtension.setCompilerOutputPath(pathToUrl(path)); compilerModuleExtension.inheritCompilerOutputPath(false); }
@Override public List<Module> commit( @NotNull Project project, @Nullable ModifiableModuleModel moduleModel, @NotNull ModulesProvider modulesProvider, @Nullable ModifiableArtifactModel modifiableArtifactModel) { Set<String> selectedAppNames = ContainerUtil.newHashSet(); for (ImportedOtpApp importedOtpApp : mySelectedOtpApps) { selectedAppNames.add(importedOtpApp.getName()); } Sdk projectSdk = fixProjectSdk(project); List<Module> createdModules = new ArrayList<Module>(); final List<ModifiableRootModel> createdRootModels = new ArrayList<ModifiableRootModel>(); final ModifiableModuleModel obtainedModuleModel = moduleModel != null ? moduleModel : ModuleManager.getInstance(project).getModifiableModel(); for (ImportedOtpApp importedOtpApp : mySelectedOtpApps) { VirtualFile ideaModuleDir = importedOtpApp.getRoot(); String ideaModuleFile = ideaModuleDir.getCanonicalPath() + File.separator + importedOtpApp.getName() + ".iml"; Module module = obtainedModuleModel.newModule(ideaModuleFile, ErlangModuleType.getInstance().getId()); createdModules.add(module); importedOtpApp.setModule(module); if (importedOtpApp.getIdeaModuleFile() == null) { ModifiableRootModel rootModel = ModuleRootManager.getInstance(module).getModifiableModel(); // Make it inherit SDK from the project. rootModel.inheritSdk(); // Initialize source and test paths. ContentEntry content = rootModel.addContentEntry(importedOtpApp.getRoot()); addSourceDirToContent(content, ideaModuleDir, "src", false); addSourceDirToContent(content, ideaModuleDir, "test", true); addIncludeDirectories(content, importedOtpApp); // Exclude standard folders excludeDirFromContent(content, ideaModuleDir, "doc"); // Initialize output paths according to Rebar conventions. CompilerModuleExtension compilerModuleExt = rootModel.getModuleExtension(CompilerModuleExtension.class); compilerModuleExt.inheritCompilerOutputPath(false); compilerModuleExt.setCompilerOutputPath(ideaModuleDir + File.separator + "ebin"); compilerModuleExt.setCompilerOutputPathForTests(ideaModuleDir + File.separator + ".eunit"); createdRootModels.add(rootModel); // Set inter-module dependencies resolveModuleDeps(rootModel, importedOtpApp, projectSdk, selectedAppNames); } } // Commit project structure. LOG.info("Commit project structure"); ApplicationManager.getApplication() .runWriteAction( new Runnable() { public void run() { for (ModifiableRootModel rootModel : createdRootModels) { rootModel.commit(); } obtainedModuleModel.commit(); } }); addErlangFacets(mySelectedOtpApps); RebarSettings.getInstance(project).setRebarPath(myRebarPath); if (myIsImportingProject) { ErlangCompilerSettings.getInstance(project).setUseRebarCompilerEnabled(true); } CompilerWorkspaceConfiguration.getInstance(project).CLEAR_OUTPUT_DIRECTORY = false; return createdModules; }