public static File getOrCreateConfigFile(
final JpsFlexBuildConfiguration bc, final ProjectDescriptor projectDescriptor)
throws IOException {
final CompilerConfigGeneratorRt generator =
new CompilerConfigGeneratorRt(
bc,
bc.getModule().getProperties().getModuleLevelCompilerOptions(),
JpsFlexProjectLevelCompilerOptionsExtension.getProjectLevelCompilerOptions(
bc.getModule().getProject()),
projectDescriptor);
String text = generator.generateConfigFileText();
if (bc.isTempBCForCompilation()) {
final JpsFlexBuildConfiguration originalBC =
bc.getModule().getProperties().findConfigurationByName(bc.getName());
final boolean makeExternalLibsMerged =
FlexCommonUtils.isFlexUnitBC(bc)
|| (originalBC != null && originalBC.getOutputType() == OutputType.Library);
final boolean makeIncludedLibsMerged = FlexCommonUtils.isRuntimeStyleSheetBC(bc);
text =
FlexCompilerConfigFileUtilBase.mergeWithCustomConfigFile(
text,
bc.getCompilerOptions().getAdditionalConfigFilePath(),
makeExternalLibsMerged,
makeIncludedLibsMerged);
}
final String name = getConfigFileName(bc, FlexCommonUtils.getBCSpecifier(bc));
return getOrCreateConfigFile(name, text);
}
private void addOtherOptions(final Element rootElement) {
final Map<String, String> options =
new THashMap<String, String>(myProjectLevelCompilerOptions.getAllOptions());
options.putAll(myModuleLevelCompilerOptions.getAllOptions());
options.putAll(myBC.getCompilerOptions().getAllOptions());
final String addOptions =
myProjectLevelCompilerOptions.getAdditionalOptions()
+ " "
+ myModuleLevelCompilerOptions.getAdditionalOptions()
+ " "
+ myBC.getCompilerOptions().getAdditionalOptions();
final List<String> contextRootInAddOptions =
FlexCommonUtils.getOptionValues(addOptions, "context-root", "compiler.context-root");
if (options.get("compiler.context-root") == null && contextRootInAddOptions.isEmpty()) {
final List<String> servicesInAddOptions =
FlexCommonUtils.getOptionValues(addOptions, "services", "compiler.services");
if (options.get("compiler.services") != null || !servicesInAddOptions.isEmpty()) {
options.put("compiler.context-root", "");
}
}
for (final Map.Entry<String, String> entry : options.entrySet()) {
addOption(rootElement, CompilerOptionInfo.getOptionInfo(entry.getKey()), entry.getValue());
}
final String namespacesRaw = options.get("compiler.namespaces.namespace");
if (namespacesRaw != null && myBC.getOutputType() == OutputType.Library) {
final String namespaces =
FlexCommonUtils.replacePathMacros(
namespacesRaw, myModule, myFlexmojos ? "" : mySdk.getHomePath());
final StringBuilder buf = new StringBuilder();
for (final String listEntry :
StringUtil.split(namespaces, CompilerOptionInfo.LIST_ENTRIES_SEPARATOR)) {
final int tabIndex = listEntry.indexOf(CompilerOptionInfo.LIST_ENTRY_PARTS_SEPARATOR);
assert tabIndex != -1 : namespaces;
final String namespace = listEntry.substring(0, tabIndex);
if (buf.length() > 0) buf.append(CompilerOptionInfo.LIST_ENTRIES_SEPARATOR);
buf.append(namespace);
}
if (buf.length() > 0) {
addOption(rootElement, CompilerOptionInfo.INCLUDE_NAMESPACES_INFO, buf.toString());
}
}
}
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);
}
}
@Nullable
private static String getCustomLinkReportPath(final JpsFlexBuildConfiguration rlmBC) {
final JpsFlexBuildConfiguration appBC =
rlmBC.getModule().getProperties().findConfigurationByName(rlmBC.getName());
if (appBC != null) {
final List<String> linkReports =
FlexCommonUtils.getOptionValues(
appBC.getCompilerOptions().getAdditionalOptions(), "link-report");
if (!linkReports.isEmpty()) {
final String path = linkReports.get(0);
if (new File(path).isFile()) return path;
final String absPath =
FlexCommonUtils.getFlexCompilerWorkDirPath(appBC.getModule().getProject()) + "/" + path;
if (new File(absPath).isFile()) return absPath;
} else {
final String configFilePath = appBC.getCompilerOptions().getAdditionalConfigFilePath();
if (!configFilePath.isEmpty()) {
final File configFile = new File(configFilePath);
if (configFile.isFile()) {
final String path =
FlexCommonUtils.findXMLElement(configFile, "<flex-config><link-report>");
if (path != null) {
if (new File(path).isFile()) return path;
// I have no idea why Flex compiler treats path relative to source root for
// "link-report" option
for (JpsModuleSourceRoot srcRoot :
appBC.getModule().getSourceRoots(JavaSourceRootType.SOURCE)) {
final String absPath = srcRoot.getFile().getPath() + "/" + path;
if (new File(absPath).isFile()) return absPath;
}
}
}
}
}
}
return null;
}
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()));
}
}
private Pair<String, ValueSource> getValueAndSource(final CompilerOptionInfo info) {
assert !info.isGroup() : info.DISPLAY_NAME;
final String bcLevelValue = myBC.getCompilerOptions().getOption(info.ID);
if (bcLevelValue != null) return Pair.create(bcLevelValue, ValueSource.BC);
final String moduleLevelValue = myModuleLevelCompilerOptions.getOption(info.ID);
if (moduleLevelValue != null) return Pair.create(moduleLevelValue, ValueSource.ModuleDefault);
final String projectLevelValue = myProjectLevelCompilerOptions.getOption(info.ID);
if (projectLevelValue != null)
return Pair.create(projectLevelValue, ValueSource.ProjectDefault);
return Pair.create(
info.getDefaultValue(
mySdk.getVersionString(), myBC.getNature(), myBC.getDependencies().getComponentSet()),
ValueSource.GlobalDefault);
}
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());
}
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());
}