private Collection<File> getClasspathFiles( ModuleChunk chunk, JpsJavaClasspathKind kind, final boolean excludeMainModuleOutput, ClasspathPart classpathPart, final boolean exportedOnly) { final Set<File> files = new LinkedHashSet<File>(); for (JpsModule module : chunk.getModules()) { JpsJavaDependenciesEnumerator enumerator = JpsJavaExtensionService.dependencies(module).includedIn(kind).recursively(); if (exportedOnly) { enumerator = enumerator.exportedOnly(); } if (classpathPart == ClasspathPart.BEFORE_JDK) { enumerator = enumerator.satisfying(new BeforeJavaSdkItemFilter(module)); } else if (classpathPart == ClasspathPart.AFTER_JDK) { enumerator = enumerator.satisfying(new AfterJavaSdkItemFilter(module)); } JpsJavaDependenciesRootsEnumerator rootsEnumerator = enumerator.classes(); if (excludeMainModuleOutput) { rootsEnumerator = rootsEnumerator.withoutSelfModuleOutput(); } files.addAll(rootsEnumerator.getRoots()); } if (classpathPart == ClasspathPart.BEFORE_JDK) { for (JpsModule module : chunk.getModules()) { JpsSdk<JpsDummyElement> sdk = module.getSdk(JpsJavaSdkType.INSTANCE); if (sdk != null) { files.addAll(sdk.getParent().getFiles(JpsOrderRootType.COMPILED)); } } } return files; }
@Override protected void addJUnitDefaultLib( JpsModule rootModel, String junitName, ExpandMacroToPathMap macroMap) { final String ideaHome = macroMap.substitute("$APPLICATION_HOME_DIR$", SystemInfo.isFileSystemCaseSensitive); final FilenameFilter junitFilter = new FilenameFilter() { @Override public boolean accept(File dir, String name) { return name.startsWith("junit"); } }; File[] junitJars = new File(ideaHome, "lib").listFiles(junitFilter); if (junitJars == null || junitJars.length == 0) { junitJars = new File(new File(ideaHome, "community"), "lib").listFiles(junitFilter); } if (junitJars != null && junitJars.length > 0) { final boolean isJUnit4 = junitName.contains("4"); File junitJar = null; for (File jar : junitJars) { final boolean isCurrentJarV4 = jar.getName().contains("4"); if (isCurrentJarV4 && isJUnit4 || !isCurrentJarV4 && !isJUnit4) { junitJar = jar; break; } } if (junitJar != null) { final JpsLibrary jpsLibrary = rootModel.addModuleLibrary(junitName, JpsJavaLibraryType.INSTANCE); jpsLibrary.addRoot(pathToUrl(junitJar.getPath()), JpsOrderRootType.COMPILED); final JpsDependenciesList dependenciesList = rootModel.getDependenciesList(); dependenciesList.addLibraryDependency(jpsLibrary); } } }
@Override protected void addNamedLibrary( JpsModule rootModel, Collection<String> unknownLibraries, boolean exported, String name, boolean applicationLevel) { if (LOG.isDebugEnabled()) { LOG.debug( "loading " + rootModel.getName() + ": adding " + (applicationLevel ? "application" : "project") + " library '" + name + "'"); } JpsElementFactory factory = JpsElementFactory.getInstance(); JpsLibraryReference libraryReference; final String level = myLibLevels.get(name); libraryReference = level != null ? factory.createLibraryReference( name, JpsLibraryTableSerializer.createLibraryTableReference(level)) : factory.createLibraryReference(name, factory.createGlobalReference()); final JpsLibraryDependency dependency = rootModel.getDependenciesList().addLibraryDependency(libraryReference); setLibraryEntryExported(dependency, exported); }
@Override public void build( @NotNull ErlangTarget target, @NotNull DirtyFilesHolder<ErlangSourceRootDescriptor, ErlangTarget> holder, @NotNull BuildOutputConsumer outputConsumer, @NotNull CompileContext context) throws ProjectBuildException, IOException { if (!holder.hasDirtyFiles() && !holder.hasRemovedFiles()) return; JpsModule module = target.getModule(); JpsProject project = module.getProject(); ErlangCompilerOptions compilerOptions = JpsErlangCompilerOptionsExtension.getOrCreateExtension(project).getOptions(); if (!compilerOptions.myUseRebarCompiler) return; String rebarExecutablePath = getRebarExecutablePath(project); if (rebarExecutablePath == null) { String errorMessage = "Rebar path is not set"; context.processMessage(new CompilerMessage(NAME, BuildMessage.Kind.ERROR, errorMessage)); throw new ProjectBuildException(errorMessage); } for (String contentRootUrl : module.getContentRootsList().getUrls()) { String contentRootPath = new URL(contentRootUrl).getPath(); File contentRootDir = new File(contentRootPath); File rebarConfigFile = new File(contentRootDir, REBAR_CONFIG_FILE_NAME); if (!rebarConfigFile.exists()) continue; runRebar( contentRootPath, rebarExecutablePath, compilerOptions.myAddDebugInfoEnabled, context); } }
@NotNull private JpsModule findModule(@NotNull String name) { for (JpsModule module : myProject.getModules()) { if (module.getName().equals(name)) { return module; } } throw new IllegalStateException("Couldn't find module " + name); }
private void doTest(boolean rebuildBeforeMake) { initProject(); rebuildAll(); for (JpsModule module : myProject.getModules()) { for (JpsModuleSourceRoot sourceRoot : module.getSourceRoots()) { processFile(sourceRoot.getFile(), rebuildBeforeMake); } } }
public void exportModuleOutputProperties() { for (JpsModule module : myModel.getProject().getModules()) { for (boolean test : new boolean[] {true, false}) { myProject.setProperty( "module." + module.getName() + ".output." + (test ? "test" : "main"), getModuleOutput(module, test)); } } }
public void testExtractDirectoryFromExcludedJar() throws IOException { String jarPath = createFile("dir/lib/j.jar"); FileUtil.copy(new File(getJUnitJarPath()), new File(jarPath)); JpsModule module = addModule("m"); String libDir = PathUtil.getParentPath(jarPath); module.getContentRootsList().addUrl(JpsPathUtil.pathToUrl(PathUtil.getParentPath(libDir))); module.getExcludeRootsList().addUrl(JpsPathUtil.pathToUrl(libDir)); final JpsArtifact a = addArtifact("a", root().extractedDir(jarPath, "/junit/textui/")); buildAll(); assertOutput(a, fs().file("ResultPrinter.class").file("TestRunner.class")); }
@Override protected void setUpModuleJdk( JpsModule rootModel, Collection<String> unknownJdks, EclipseModuleManager eclipseModuleManager, String jdkName) { if (LOG.isDebugEnabled()) { LOG.debug("loading " + rootModel.getName() + ": set module jdk " + jdkName); } rootModel.getDependenciesList().addSdkDependency(JpsJavaSdkType.INSTANCE); }
private static Set<String> getModuleDependencies(JpsModule module, boolean includeTests) { Set<JpsModule> modules = JpsJavaExtensionService.dependencies(module) .recursively() .includedIn(JpsJavaClasspathKind.compile(includeTests)) .getModules(); Set<String> names = new HashSet<String>(); for (JpsModule depModule : modules) { names.add(depModule.getName()); } return names; }
public void readClasspath( JpsModule model, final String testPattern, Element classpathElement, JpsMacroExpander expander) throws IOException { LOG.debug("start loading classpath for " + model.getName()); final HashSet<String> libs = new HashSet<String>(); for (Object o : classpathElement.getChildren(EclipseXml.CLASSPATHENTRY_TAG)) { try { readClasspathEntry( model, new ArrayList<String>(), new ArrayList<String>(), new HashSet<String>(), testPattern, (Element) o, 0, null, expander.getExpandMacroMap(), libs); } catch (ConversionException e) { throw new IOException(e); } } boolean foundSdkDependency = false; JpsDependenciesList dependenciesList = model.getDependenciesList(); for (JpsDependencyElement element : dependenciesList.getDependencies()) { if (element instanceof JpsSdkDependency) { foundSdkDependency = true; break; } } if (!foundSdkDependency) { dependenciesList.addSdkDependency(JpsJavaSdkType.INSTANCE); } if (LOG.isDebugEnabled()) { String name = model.getName(); LOG.debug( "finished loading classpath for " + name + " (" + dependenciesList.getDependencies().size() + " items):"); for (JpsDependencyElement element : dependenciesList.getDependencies()) { LOG.debug(" [" + name + "]:" + element.toString()); } } }
private void addLibClasses(final Element rootElement) throws IOException { final JpsCompilerExcludes excludes = JpsJavaExtensionService.getInstance() .getOrCreateCompilerConfiguration(myModule.getProject()) .getCompilerExcludes(); final Ref<Boolean> noClasses = new Ref<Boolean>(true); for (JpsTypedModuleSourceRoot srcRoot : myModule.getSourceRoots(JavaSourceRootType.SOURCE)) { final File srcFolder = JpsPathUtil.urlToFile(srcRoot.getUrl()); if (srcFolder.isDirectory()) { processFilesRecursively( srcFolder, new Processor<File>() { public boolean process(final File file) { if (myProjectDescriptor.getIgnoredFileIndex().isIgnored(file.getName())) return false; if (file.isDirectory()) return true; if (!FlexCommonUtils.isSourceFile(file.getName())) return true; if (excludes.isExcluded(file)) return true; String packageRelativePath = FileUtil.getRelativePath(srcFolder, file.getParentFile()); assert packageRelativePath != null : srcFolder.getPath() + ": " + file.getPath(); if (packageRelativePath.equals(".")) packageRelativePath = ""; final String packageName = packageRelativePath.replace(File.separatorChar, '.'); final String qName = StringUtil.getQualifiedName( packageName, FileUtil.getNameWithoutExtension(file)); if (isSourceFileWithPublicDeclaration(file)) { addOption(rootElement, CompilerOptionInfo.INCLUDE_CLASSES_INFO, qName); noClasses.set(false); } return true; } }); } } if (noClasses.get() && myBC.getCompilerOptions().getFilesToIncludeInSWC().isEmpty() && !Utils.IS_TEST_MODE) { throw new IOException( FlexCommonBundle.message( "nothing.to.compile.in.library", myModule.getName(), myBC.getName())); } }
public void testCopyExcludedFolder() { // explicitly added excluded files should be copied (e.g. compile output) final String file = createFile("xxx/excluded/a.txt"); createFile("xxx/excluded/CVS"); final String excluded = PathUtil.getParentPath(file); final String dir = PathUtil.getParentPath(excluded); final JpsModule module = addModule("myModule"); module.getContentRootsList().addUrl(JpsPathUtil.pathToUrl(dir)); module.getExcludeRootsList().addUrl(JpsPathUtil.pathToUrl(excluded)); final JpsArtifact a = addArtifact(root().dirCopy(excluded)); buildAll(); assertOutput(a, fs().file("a.txt")); }
public void testCopyExcludedFile() { // excluded files under non-excluded directory should not be copied final String file = createFile("xxx/excluded/a.txt"); createFile("xxx/b.txt"); createFile("xxx/CVS"); final String dir = PathUtil.getParentPath(PathUtil.getParentPath(file)); JpsModule module = addModule("myModule"); module.getContentRootsList().addUrl(JpsPathUtil.pathToUrl(dir)); module.getExcludeRootsList().addUrl(JpsPathUtil.pathToUrl(PathUtil.getParentPath(file))); final JpsArtifact a = addArtifact(root().dirCopy(dir)); buildAll(); assertOutput(a, fs().file("b.txt")); }
private static boolean isInTestSourceRoot(final JpsModule module, final String path) { for (JpsModuleSourceRoot testSrcRoot : module.getSourceRoots(JavaSourceRootType.TEST_SOURCE)) { final String testSrcRootPath = JpsPathUtil.urlToPath(testSrcRoot.getUrl()); if (path.startsWith(testSrcRootPath + "/")) return true; } return false; }
@Nullable public File getAnnotationProcessorGeneratedSourcesOutputDir( JpsModule module, final boolean forTests, String sourceDirName) { if (!StringUtil.isEmpty(sourceDirName)) { List<String> roots = module.getContentRootsList().getUrls(); if (roots.isEmpty()) { return null; } if (roots.size() > 1) { roots = new ArrayList<String>(roots); // sort roots to get deterministic result Collections.sort( roots, new Comparator<String>() { @Override public int compare(String o1, String o2) { return o1.compareTo(o2); } }); } return new File(JpsPathUtil.urlToFile(roots.get(0)), sourceDirName); } final File outputDir = getModuleOutputDir(module, forTests); if (outputDir == null) { return null; } final File parentFile = outputDir.getParentFile(); if (parentFile == null) { return null; } return new File(parentFile, outputDir.getName() + "_" + DEFAULT_GENERATED_DIR_NAME); }
public void setupOutput(JpsModule rootModel, final String path) { final JpsJavaModuleExtension extension = getService().getOrCreateModuleExtension(rootModel); String outputUrl = pathToUrl(path); extension.setOutputUrl(outputUrl); extension.setTestOutputUrl(outputUrl); // extension.setInheritOutput(false); rootModel.getDependenciesList().addModuleSourceDependency(); }
@Override public boolean value(JpsDependencyElement dependency) { if (myModule.equals(dependency.getContainingModule()) && dependency instanceof JpsSdkDependency && ((JpsSdkDependency) dependency).getSdkType().equals(JpsJavaSdkType.INSTANCE)) { mySdkFound = true; return false; } return mySdkFound; }
@Override public boolean value(JpsDependencyElement dependency) { boolean isJavaSdk = dependency instanceof JpsSdkDependency && ((JpsSdkDependency) dependency).getSdkType().equals(JpsJavaSdkType.INSTANCE); if (myModule.equals(dependency.getContainingModule()) && isJavaSdk) { mySdkFound = true; } return !mySdkFound && !isJavaSdk; }
@Override protected void addInvalidModuleEntry(JpsModule rootModel, boolean exported, String moduleName) { final JpsElementFactory elementFactory = JpsElementFactory.getInstance(); final JpsDependenciesList dependenciesList = rootModel.getDependenciesList(); final JpsModuleDependency dependency = dependenciesList.addModuleDependency(elementFactory.createModuleReference(moduleName)); final JpsJavaDependencyExtension extension = getService().getOrCreateDependencyExtension(dependency); extension.setExported(exported); }
private void addFilesIncludedInSwc(final Element rootElement) { final JpsCompilerExcludes excludes = JpsJavaExtensionService.getInstance() .getOrCreateCompilerConfiguration(myModule.getProject()) .getCompilerExcludes(); final Map<String, String> filePathToPathInSwc = new THashMap<String, String>(); for (String path : myBC.getCompilerOptions().getFilesToIncludeInSWC()) { final File fileOrDir = new File(path); if (excludes.isExcluded(fileOrDir)) continue; if (myProjectDescriptor.getIgnoredFileIndex().isIgnored(fileOrDir.getName())) continue; final String baseRelativePath = StringUtil.notNullize( FlexCommonUtils.getPathRelativeToSourceRoot(myModule, fileOrDir.getPath()), fileOrDir.getName()); if (fileOrDir.isDirectory()) { processFilesRecursively( fileOrDir, new Processor<File>() { public boolean process(final File file) { if (myProjectDescriptor.getIgnoredFileIndex().isIgnored(file.getName())) return false; if (!file.isDirectory() && !FlexCommonUtils.isSourceFile(file.getName()) && !excludes.isExcluded(file)) { final String relativePath = FileUtil.getRelativePath(fileOrDir, file); assert relativePath != null; final String pathInSwc = baseRelativePath.isEmpty() ? relativePath : baseRelativePath + "/" + relativePath; filePathToPathInSwc.put(file.getPath(), pathInSwc); } return true; } }); } else if (fileOrDir.isFile()) { filePathToPathInSwc.put(fileOrDir.getPath(), baseRelativePath); } } for (Map.Entry<String, String> entry : filePathToPathInSwc.entrySet()) { final String value = FileUtil.toSystemIndependentName(entry.getValue()) + CompilerOptionInfo.LIST_ENTRY_PARTS_SEPARATOR + FileUtil.toSystemIndependentName(entry.getKey()); addOption(rootElement, CompilerOptionInfo.INCLUDE_FILE_INFO, value); } }
protected <T extends JpsElement> JpsModule addModule( String moduleName, String[] srcPaths, @Nullable String outputPath, @Nullable String testOutputPath, JpsSdk<T> sdk) { JpsModule module = myProject.addModule(moduleName, JpsJavaModuleType.INSTANCE); final JpsSdkType<T> sdkType = sdk.getSdkType(); final JpsSdkReferencesTable sdkTable = module.getSdkReferencesTable(); sdkTable.setSdkReference(sdkType, sdk.createReference()); if (sdkType instanceof JpsJavaSdkTypeWrapper) { final JpsSdkReference<T> wrapperRef = sdk.createReference(); sdkTable.setSdkReference( JpsJavaSdkType.INSTANCE, JpsJavaExtensionService.getInstance() .createWrappedJavaSdkReference((JpsJavaSdkTypeWrapper) sdkType, wrapperRef)); } module.getDependenciesList().addSdkDependency(sdkType); if (srcPaths.length > 0 || outputPath != null) { for (String srcPath : srcPaths) { module.getContentRootsList().addUrl(JpsPathUtil.pathToUrl(srcPath)); module.addSourceRoot(JpsPathUtil.pathToUrl(srcPath), JavaSourceRootType.SOURCE); } JpsJavaModuleExtension extension = JpsJavaExtensionService.getInstance().getOrCreateModuleExtension(module); if (outputPath != null) { extension.setOutputUrl(JpsPathUtil.pathToUrl(outputPath)); if (!StringUtil.isEmpty(testOutputPath)) { extension.setTestOutputUrl(JpsPathUtil.pathToUrl(testOutputPath)); } else { extension.setTestOutputUrl(extension.getOutputUrl()); } } else { extension.setInheritOutput(true); } } return module; }
@Override protected void addModuleLibrary( JpsModule rootModel, Element element, boolean exported, String libName, String url, String srcUrl, ExpandMacroToPathMap macroMap) { final JpsLibrary jpsLibrary = rootModel.addModuleLibrary(libName, JpsJavaLibraryType.INSTANCE); final JpsDependenciesList dependenciesList = rootModel.getDependenciesList(); final JpsLibraryDependency dependency = dependenciesList.addLibraryDependency(jpsLibrary); url = StringUtil.trimStart(url, "file://"); final String linked = expandLinkedResourcesPath(url, macroMap); if (linked != null) { url = pathToUrl(linked); } else { url = expandEclipsePath2Url(rootModel, url); } LOG.debug("loading " + rootModel.getName() + ": adding module library " + libName + ": " + url); jpsLibrary.addRoot(url, JpsOrderRootType.COMPILED); setLibraryEntryExported(dependency, exported); }
private void addInputOutputPaths(final Element rootElement) throws IOException { if (myBC.getOutputType() == OutputType.Library) { addFilesIncludedInSwc(rootElement); if (!myFlexmojos) { addLibClasses(rootElement); } } else { final InfoFromConfigFile info = InfoFromConfigFile.getInfoFromConfigFile( myBC.getCompilerOptions().getAdditionalConfigFilePath()); final String pathToMainClassFile = myCSS ? myBC.getMainClass() : myFlexUnit ? getPathToFlexUnitMainClass( myProjectDescriptor, myBC.getNature(), myBC.getMainClass()) : FlexCommonUtils.getPathToMainClassFile(myBC.getMainClass(), myModule); if (pathToMainClassFile.isEmpty() && info.getMainClass(myModule) == null && !Utils.IS_TEST_MODE) { throw new IOException( FlexCommonBundle.message( "bc.incorrect.main.class", myBC.getMainClass(), myBC.getName(), myModule.getName())); } if (!pathToMainClassFile.isEmpty()) { addOption( rootElement, CompilerOptionInfo.MAIN_CLASS_INFO, FileUtil.toSystemIndependentName(pathToMainClassFile)); } } addOption(rootElement, CompilerOptionInfo.OUTPUT_PATH_INFO, myBC.getActualOutputFilePath()); }
public static ThriftCompilerOptions getSettings(JpsModule module) { final ThriftCompilerOptions config = module.getContainer().getChild(ROLE); return config == null ? new ThriftCompilerOptions() : config; }
@Override public ExitCode build( CompileContext context, ModuleChunk chunk, DirtyFilesHolder<JavaSourceRootDescriptor, ModuleBuildTarget> dirtyFilesHolder, OutputConsumer outputConsumer) throws ProjectBuildException, IOException { final IceConfig config = context.getProjectDescriptor().getProject().getContainer().getChild(IceConfig.ROLE); IceConfig iceConfig = config == null ? new IceConfig("") : config; File frameworkHome = JpsPathUtil.urlToFile(iceConfig.getFrameworkHomeUrl()); List<String> includes = new ArrayList<String>(); for (String include : iceConfig.getIncludeUrls()) { includes.add(JpsPathUtil.urlToFile(include).getAbsolutePath()); } final Map<ModuleBuildTarget, List<File>> toCompile = collectChangedFiles(context, dirtyFilesHolder); if (toCompile.isEmpty()) { return ExitCode.NOTHING_DONE; } for (Map.Entry<ModuleBuildTarget, List<File>> e : toCompile.entrySet()) { final ModuleBuildTarget target = e.getKey(); final JpsModule module = target.getModule(); SliceCompilerSettings settings = module.getContainer().getChild(SliceCompilerSettings.ROLE); final SliceCompilerSettings facetConfig = settings == null ? new SliceCompilerSettings() : settings; final List<File> sourceFiles = e.getValue(); List<Target> translators = facetConfig.getComponents(); if (translators.isEmpty()) { context.processMessage( new CompilerMessage( getPresentableName(), BuildMessage.Kind.WARNING, "No valid translators found for module " + module.getName() + ". Check facet configuration.")); continue; } // Translate files for (Target c : translators) { final File outputDir = c.getOutputFile(); if (facetConfig.isCleanOutput()) { try { FileUtils.cleanDirectory(outputDir); } catch (IOException ex) { context.processMessage( new CompilerMessage( getPresentableName(), BuildMessage.Kind.ERROR, "Failed to empty target directory: " + outputDir.getPath() + " . Error: " + ex.getMessage())); return ExitCode.ABORT; } } compileFiles( context, frameworkHome, includes, target, sourceFiles, c.getComponent(), outputDir); } } return ExitCode.OK; }
private void compileFiles( final CompileContext context, File frameworkHome, List<String> includes, ModuleBuildTarget buildTarget, List<File> sourceFiles, IceComponent target, File outputDir) throws StopBuildException { final JpsModule module = buildTarget.getModule(); final String translatorName = target.getTranslatorName(); if (outputDir == null) { context.processMessage( new CompilerMessage( getPresentableName(), BuildMessage.Kind.WARNING, "Output folder is not specified for " + translatorName + " in module " + module.getName() + ". Check facet configuration.")); return; } List<String> command = new ArrayList<String>(); command.add(target.getTranslatorPath(frameworkHome).getAbsolutePath()); command.add("--list-generated"); command.add("--output-dir"); final String outputDirPath = outputDir.getAbsolutePath(); command.add(outputDirPath); for (String include : includes) { command.add("-I" + include); } for (JpsModuleSourceRoot contentRoot : module.getSourceRoots()) { command.add("-I" + contentRoot.getFile().getAbsolutePath()); } for (File source : sourceFiles) { command.add(source.getAbsolutePath()); } try { Process process = new ProcessBuilder().command(command).start(); BaseOSProcessHandler handler = new BaseOSProcessHandler( process, StringUtil.join(command, " "), CharsetToolkit.UTF8_CHARSET); final AtomicBoolean hasErrors = new AtomicBoolean(); handler.addProcessListener( new ProcessAdapter() { final StringBuilder errorOutput = new StringBuilder(); final StringBuilder stdOutput = new StringBuilder(); @Override public void onTextAvailable(ProcessEvent event, Key outputType) { if (outputType == ProcessOutputTypes.STDERR) { errorOutput.append(event.getText()); } else if (outputType == ProcessOutputTypes.STDOUT) { stdOutput.append(event.getText()); } } @Override public void processTerminated(ProcessEvent event) { Document res; final String stdout = stdOutput.toString(); try { res = JDOMUtil.loadDocument(stdout); } catch (Exception e) { context.processMessage( new CompilerMessage( BUILDER_NAME, BuildMessage.Kind.ERROR, "Can't process compiler output: " + stdout)); hasErrors.set(true); return; } int exitCode = event.getExitCode(); if (exitCode != 0) { for (Element source : res.getRootElement().getChildren("source")) { final Element output = source.getChild("output"); if (output != null) { String message = output.getTextTrim(); for (String line : message.split("\n")) { int separatorIndex = line.indexOf(": "); final String path; final long lineNumber; if (separatorIndex <= 0) { path = null; lineNumber = -1L; } else { int lineSep = line.lastIndexOf(':', separatorIndex - 1); if (lineSep == -1) { path = null; lineNumber = -1L; } else { path = line.substring(0, lineSep); long l; try { l = Long.parseLong(line.substring(lineSep + 1, separatorIndex)); } catch (NumberFormatException e) { l = -1L; } lineNumber = l; } } context.processMessage( new CompilerMessage( BUILDER_NAME, BuildMessage.Kind.ERROR, line, path, -1L, -1L, -1L, lineNumber, -1L)); } } } final String stdErr = errorOutput.toString(); if (stdErr.length() > 0) { context.processMessage( new CompilerMessage(BUILDER_NAME, BuildMessage.Kind.ERROR, stdErr)); } context.processMessage( new CompilerMessage( BUILDER_NAME, BuildMessage.Kind.ERROR, "translator '" + translatorName + "' for '" + module.getName() + "' finished with exit code " + exitCode)); hasErrors.set(true); } else { final FileGeneratedEvent msg = new FileGeneratedEvent(); for (Element source : res.getRootElement().getChildren("source")) { for (Element file : source.getChildren("file")) { final String fileName = file.getAttributeValue("name"); if (fileName.startsWith(outputDirPath)) { msg.add(outputDirPath, fileName.substring(outputDirPath.length() + 1)); } } } context.processMessage(msg); } } }); handler.startNotify(); handler.waitFor(); if (hasErrors.get()) { throw new StopBuildException(); } } catch (IOException e) { context.processMessage( new CompilerMessage( getPresentableName(), BuildMessage.Kind.ERROR, "Failed to translate files with " + translatorName + ". Error: " + e.getMessage())); } }
@Override public void build( @NotNull ErlangTarget target, @NotNull DirtyFilesHolder<ErlangSourceRootDescriptor, ErlangTarget> holder, @NotNull BuildOutputConsumer outputConsumer, @NotNull final CompileContext context) throws ProjectBuildException, IOException { LOG.debug(target.getPresentableName()); final Ref<Boolean> hasDirtyFiles = Ref.create(false); holder.processDirtyFiles( new FileProcessor<ErlangSourceRootDescriptor, ErlangTarget>() { @Override public boolean apply(ErlangTarget target, File file, ErlangSourceRootDescriptor root) throws IOException { hasDirtyFiles.set(true); return true; } }); if (!hasDirtyFiles.get() && !holder.hasRemovedFiles()) { return; } JpsModule module = target.getModule(); JpsJavaExtensionService instance = JpsJavaExtensionService.getInstance(); File outputDirectory = instance.getOutputDirectory(module, target.isTests()); if (outputDirectory == null) { context.processMessage( new CompilerMessage( NAME, BuildMessage.Kind.ERROR, "No output dir for module " + module.getName())); throw new ProjectBuildException(); } if (!outputDirectory.exists()) FileUtil.createDirectory(outputDirectory); JpsSdk<JpsDummyElement> sdk = module.getSdk(JpsErlangSdkType.INSTANCE); if (sdk == null) { context.processMessage( new CompilerMessage( NAME, BuildMessage.Kind.ERROR, "No SDK for module " + module.getName())); throw new ProjectBuildException(); } File executable = JpsErlangSdkType.getByteCodeCompilerExecutable(sdk.getHomePath()); List<String> commandList = new ArrayList<String>(); commandList.add(executable.getAbsolutePath()); CommonProcessors.CollectProcessor<File> processor = new CommonProcessors.CollectProcessor<File>() { @Override protected boolean accept(File file) { return !file.isDirectory() && FileUtilRt.extensionEquals(file.getName(), "erl"); } }; for (JpsModuleSourceRoot root : module.getSourceRoots()) { commandList.add("-I"); commandList.add(root.getFile().getAbsolutePath()); FileUtil.processFilesRecursively(root.getFile(), processor); } for (File f : processor.getResults()) { commandList.add(f.getAbsolutePath()); } LOG.debug(StringUtil.join(commandList, " ")); Process process = new ProcessBuilder(commandList).directory(outputDirectory).start(); BaseOSProcessHandler handler = new BaseOSProcessHandler(process, null, Charset.defaultCharset()); ProcessAdapter adapter = new ProcessAdapter() { @Override public void onTextAvailable(ProcessEvent event, Key outputType) { ErlangCompilerError error = ErlangCompilerError.create("", event.getText()); if (error != null) { boolean isError = error.getCategory() == CompilerMessageCategory.ERROR; BuildMessage.Kind kind = isError ? BuildMessage.Kind.ERROR : BuildMessage.Kind.WARNING; CompilerMessage msg = new CompilerMessage( NAME, kind, error.getErrorMessage(), VirtualFileManager.extractPath(error.getUrl()), -1, -1, -1, error.getLine(), -1); context.processMessage(msg); } } }; handler.addProcessListener(adapter); handler.startNotify(); handler.waitFor(); }
@Override protected void addSourceFolderToCurrentContentRoot( JpsModule rootModel, String srcUrl, boolean testFolder) { rootModel.addSourceRoot( srcUrl, testFolder ? JavaSourceRootType.TEST_SOURCE : JavaSourceRootType.SOURCE); }
private void addSourcePaths(final Element rootElement) { final String localeValue = getValueAndSource(CompilerOptionInfo.getOptionInfo("compiler.locale")).first; final List<String> locales = StringUtil.split(localeValue, CompilerOptionInfo.LIST_ENTRIES_SEPARATOR); // when adding source paths we respect locales set both in UI and in Additional compiler options locales.addAll( FlexCommonUtils.getOptionValues( myProjectLevelCompilerOptions.getAdditionalOptions(), "locale", "compiler.locale")); locales.addAll( FlexCommonUtils.getOptionValues( myModuleLevelCompilerOptions.getAdditionalOptions(), "locale", "compiler.locale")); locales.addAll( FlexCommonUtils.getOptionValues( myBC.getCompilerOptions().getAdditionalOptions(), "locale", "compiler.locale")); final Set<String> sourcePathsWithLocaleToken = new THashSet<String>(); // Set - to avoid duplication of paths like "locale/{locale}" final List<String> sourcePathsWithoutLocaleToken = new LinkedList<String>(); for (JpsModuleSourceRoot srcRoot : myModule.getSourceRoots(JavaSourceRootType.SOURCE)) { final String srcRootPath = JpsPathUtil.urlToPath(srcRoot.getUrl()); if (locales.contains(PathUtilRt.getFileName(srcRootPath))) { sourcePathsWithLocaleToken.add( PathUtilRt.getParentPath(srcRootPath) + "/" + FlexCommonUtils.LOCALE_TOKEN); } else { sourcePathsWithoutLocaleToken.add(srcRootPath); } } if (includeTestRoots()) { for (JpsModuleSourceRoot srcRoot : myModule.getSourceRoots(JavaSourceRootType.TEST_SOURCE)) { final String srcRootPath = JpsPathUtil.urlToPath(srcRoot.getUrl()); if (locales.contains(PathUtilRt.getFileName(srcRootPath))) { sourcePathsWithLocaleToken.add( PathUtilRt.getParentPath(srcRootPath) + "/" + FlexCommonUtils.LOCALE_TOKEN); } else { sourcePathsWithoutLocaleToken.add(srcRootPath); } } } final StringBuilder sourcePathBuilder = new StringBuilder(); if (myCSS) { final String cssFolderPath = PathUtilRt.getParentPath(myBC.getMainClass()); if (!sourcePathsWithoutLocaleToken.contains(cssFolderPath)) { sourcePathBuilder.append(cssFolderPath); } } for (final String sourcePath : sourcePathsWithLocaleToken) { if (sourcePathBuilder.length() > 0) { sourcePathBuilder.append(CompilerOptionInfo.LIST_ENTRIES_SEPARATOR); } sourcePathBuilder.append(sourcePath); } for (final String sourcePath : sourcePathsWithoutLocaleToken) { if (sourcePathBuilder.length() > 0) { sourcePathBuilder.append(CompilerOptionInfo.LIST_ENTRIES_SEPARATOR); } sourcePathBuilder.append(sourcePath); } addOption(rootElement, CompilerOptionInfo.SOURCE_PATH_INFO, sourcePathBuilder.toString()); }