package com.intellij.lang.javascript.flex.projectStructure.conversion;
import com.intellij.conversion.CannotConvertException;
import com.intellij.conversion.ConversionProcessor;
import com.intellij.conversion.ModuleSettings;
import com.intellij.facet.FacetManagerImpl;
import com.intellij.flex.model.bc.CompilerOptionInfo;
import com.intellij.flex.model.bc.OutputType;
import com.intellij.flex.model.bc.TargetPlatform;
import com.intellij.lang.javascript.flex.FlexModuleType;
import com.intellij.lang.javascript.flex.FlexUtils;
import com.intellij.lang.javascript.flex.build.FlexBuildConfiguration;
import com.intellij.lang.javascript.flex.library.FlexLibraryProperties;
import com.intellij.lang.javascript.flex.library.FlexLibraryType;
import com.intellij.lang.javascript.flex.projectStructure.FlexCompositeSdk;
import com.intellij.lang.javascript.flex.projectStructure.model.*;
import com.intellij.lang.javascript.flex.projectStructure.model.impl.ConversionHelper;
import com.intellij.lang.javascript.flex.projectStructure.model.impl.Factory;
import com.intellij.lang.javascript.flex.projectStructure.model.impl.FlexBuildConfigurationManagerImpl;
import com.intellij.lang.javascript.flex.projectStructure.model.impl.FlexLibraryIdGenerator;
import com.intellij.lang.javascript.flex.projectStructure.options.BCUtils;
import com.intellij.lang.javascript.flex.sdk.FlexSdkUtils;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.module.StdModuleTypes;
import com.intellij.openapi.projectRoots.ProjectJdkTable;
import com.intellij.openapi.projectRoots.Sdk;
import com.intellij.openapi.roots.CompilerModuleExtension;
import com.intellij.openapi.roots.DependencyScope;
import com.intellij.openapi.roots.OrderRootType;
import com.intellij.openapi.roots.impl.*;
import com.intellij.openapi.roots.impl.libraries.JarDirectories;
import com.intellij.openapi.roots.impl.libraries.LibraryImpl;
import com.intellij.openapi.util.DefaultJDOMExternalizer;
import com.intellij.openapi.util.InvalidDataException;
import com.intellij.openapi.util.JDOMUtil;
import com.intellij.openapi.util.io.FileFilters;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.openapi.vfs.JarFileSystem;
import com.intellij.openapi.vfs.LocalFileSystem;
import com.intellij.openapi.vfs.VfsUtilCore;
import com.intellij.util.ArrayUtil;
import com.intellij.util.Function;
import com.intellij.util.PathUtil;
import com.intellij.util.containers.ContainerUtil;
import com.intellij.util.xmlb.XmlSerializer;
import gnu.trove.THashMap;
import org.jdom.Attribute;
import org.jdom.Element;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jps.model.serialization.JDomSerializationUtil;
import org.jetbrains.jps.model.serialization.facet.JpsFacetSerializer;
import org.jetbrains.jps.model.serialization.java.JpsJavaModelSerializerExtension;
import java.io.File;
import java.util.*;
class FlexModuleConverter extends ConversionProcessor<ModuleSettings> {
private static final Logger LOG = Logger.getInstance(FlexModuleConverter.class.getName());
private static final String FLEX_FACET_TYPE_ID = "flex";
private static final @NonNls String FLEX_SDK_ATTR_NAME = "flex_sdk";
private static final String NAMESPACE_AND_MANIFEST_FILE_INFO_LIST_ELEMENT_NAME = "NAMESPACE_AND_MANIFEST_FILE_INFO_LIST";
private static final String CONDITIONAL_COMPILER_DEFINITION_LIST_ELEMENT_NAME = "CONDITIONAL_COMPILATION_DEFINITION_LIST";
private static final String CSS_FILES_LIST_ELEMENT_NAME = "CSS_FILES_LIST";
private static final String FILE_PATH_ELEMENT_NAME = "FILE_PATH";
private final ConversionParams myParams;
public FlexModuleConverter(ConversionParams params) {
myParams = params;
}
@Override
public boolean isConversionNeeded(ModuleSettings moduleSettings) {
return isConversionNeededStatic(moduleSettings);
}
static boolean isConversionNeededStatic(ModuleSettings moduleSettings) {
if (!hasFlex(moduleSettings)) return false;
return moduleSettings.getComponentElement(FlexBuildConfigurationManagerImpl.COMPONENT_NAME) == null;
}
static boolean hasFlex(ModuleSettings moduleSettings) {
return isFlexModule(moduleSettings) || !getFlexFacets(moduleSettings).isEmpty();
}
public static boolean isFlexModule(ModuleSettings moduleSettings) {
return FlexModuleType.MODULE_TYPE_ID.equals(moduleSettings.getModuleType());
}
private static boolean isJavaModule(ModuleSettings module) {
return StdModuleTypes.JAVA.getId().equals(module.getModuleType());
}
public static List<Element> getFlexFacets(ModuleSettings module) {
if (!isJavaModule(module)) return Collections.emptyList();
return new ArrayList<>(module.getFacetElements(FLEX_FACET_TYPE_ID));
}
@Override
public void process(ModuleSettings moduleSettings) throws CannotConvertException {
FlexBuildConfigurationManagerImpl configurationManager = ConversionHelper.createBuildConfigurationManager();
Collection<Element> orderEntriesToAdd = new ArrayList<>();
Set<String> usedSdksNames = new HashSet<>();
final Set<Element> usedModuleLibrariesEntries = new HashSet<>();
if (isFlexModule(moduleSettings)) {
ModifiableFlexBuildConfiguration newConfiguration =
(ModifiableFlexBuildConfiguration)configurationManager.getBuildConfigurations()[0];
newConfiguration.setName(generateModuleBcName(moduleSettings));
Element oldConfigurationElement = moduleSettings.getComponentElement(FlexBuildConfiguration.COMPONENT_NAME);
FlexBuildConfiguration oldConfiguration =
oldConfigurationElement != null ? XmlSerializer.deserialize(oldConfigurationElement, FlexBuildConfiguration.class) : null;
processConfiguration(oldConfiguration, newConfiguration, moduleSettings, false, null, usedSdksNames, orderEntriesToAdd,
usedModuleLibrariesEntries);
if (oldConfigurationElement != null) {
oldConfigurationElement.detach();
}
}
else {
List<Element> flexFacets = getFlexFacets(moduleSettings);
for (int i = 0; i < flexFacets.size(); i++) {
Element facet = flexFacets.get(i);
ModifiableFlexBuildConfiguration newConfiguration;
if (i == 0) {
newConfiguration = (ModifiableFlexBuildConfiguration)configurationManager.getBuildConfigurations()[0];
}
else {
newConfiguration = ConversionHelper.createBuildConfiguration(configurationManager);
}
newConfiguration.setName(generateFacetBcName(flexFacets, facet));
Element oldConfigurationElement = facet.getChild(JpsFacetSerializer.CONFIGURATION_TAG);
if (oldConfigurationElement != null) {
FlexBuildConfiguration oldConfiguration = XmlSerializer.deserialize(oldConfigurationElement, FlexBuildConfiguration.class);
try {
readNamespaceAndManifestInfoList(oldConfigurationElement, oldConfiguration);
readConditionalCompilerDefinitionList(oldConfigurationElement, oldConfiguration);
readCssFilesList(oldConfigurationElement, oldConfiguration);
}
catch (InvalidDataException ignore) {/* unlucky */}
final String facetSdkName = oldConfigurationElement.getAttributeValue(FLEX_SDK_ATTR_NAME);
processConfiguration(oldConfiguration, newConfiguration, moduleSettings, true, facetSdkName, usedSdksNames, orderEntriesToAdd,
usedModuleLibrariesEntries);
}
else {
processConfiguration(null, newConfiguration, moduleSettings, true, null, usedSdksNames, orderEntriesToAdd,
usedModuleLibrariesEntries);
}
}
moduleSettings.setModuleType(FlexModuleType.MODULE_TYPE_ID);
moduleSettings.getComponentElement(FacetManagerImpl.COMPONENT_NAME).getChildren(JpsFacetSerializer.FACET_TAG).removeAll(flexFacets);
}
Collection<Element> allEntries = new ArrayList<>();
allEntries.addAll(usedModuleLibrariesEntries);
allEntries.addAll(orderEntriesToAdd);
for (Element orderEntry : allEntries) {
if (DependencyScope.readExternal(orderEntry) == DependencyScope.TEST) {
orderEntry.removeAttribute(DependencyScope.SCOPE_ATTR);
}
}
if (!usedSdksNames.isEmpty()) {
Element sdkEntryElement = new Element(OrderEntryFactory.ORDER_ENTRY_ELEMENT_NAME);
sdkEntryElement.setAttribute(OrderEntryFactory.ORDER_ENTRY_TYPE_ATTR, "jdk");
final String compositeSdkName = FlexCompositeSdk.getCompositeName(ArrayUtil.toStringArray(usedSdksNames));
sdkEntryElement.setAttribute(ModuleJdkOrderEntryImpl.JDK_NAME_ATTR, compositeSdkName);
sdkEntryElement.setAttribute(ModuleJdkOrderEntryImpl.JDK_TYPE_ATTR, FlexCompositeSdk.TYPE_ID);
moduleSettings.getOrderEntries().add(sdkEntryElement);
}
Element rootManagerElement = JDomSerializationUtil.findOrCreateComponentElement(moduleSettings.getRootElement(),
ModuleSettings.MODULE_ROOT_MANAGER_COMPONENT);
rootManagerElement.addContent(orderEntriesToAdd);
Element componentElement =
JDomSerializationUtil.findOrCreateComponentElement(moduleSettings.getRootElement(), FlexBuildConfigurationManagerImpl.COMPONENT_NAME);
addContent(ConversionHelper.serialize(configurationManager), componentElement);
ignoreInapplicableFacets(moduleSettings);
}
private void ignoreInapplicableFacets(ModuleSettings module) {
boolean allowFlexFacets = isJavaModule(module);
final Element facetManager = module.getComponentElement(FacetManagerImpl.COMPONENT_NAME);
for (Element facet : JDOMUtil.getChildren(facetManager, JpsFacetSerializer.FACET_TAG)) {
String type = facet.getAttributeValue(JpsFacetSerializer.TYPE_ATTRIBUTE);
if (allowFlexFacets && FLEX_FACET_TYPE_ID.equals(type)) {
continue;
}
String name = facet.getAttributeValue(JpsFacetSerializer.NAME_ATTRIBUTE);
myParams.ignoreInvalidFacet(module.getModuleName(), type, name);
}
}
private void processConfiguration(@Nullable FlexBuildConfiguration oldConfiguration,
ModifiableFlexBuildConfiguration newBuildConfiguration,
final ModuleSettings module,
boolean facet,
@Nullable String facetSdkName,
Set<String> usedSdksNames,
Collection<Element> orderEntriesToAdd,
Set<Element> usedModuleLibrariesEntries) throws CannotConvertException {
if (oldConfiguration == null) {
newBuildConfiguration.setOutputType(OutputType.Application);
}
else {
if (FlexBuildConfiguration.LIBRARY.equals(oldConfiguration.OUTPUT_TYPE)) {
newBuildConfiguration.setOutputType(OutputType.Library);
}
else {
newBuildConfiguration.setOutputType(OutputType.Application);
}
if (newBuildConfiguration.getOutputType() == OutputType.Application) {
newBuildConfiguration.setMainClass(oldConfiguration.MAIN_CLASS);
myParams.addAppModuleAndBCName(module.getModuleName(), newBuildConfiguration.getName());
}
newBuildConfiguration.setOutputFileName(oldConfiguration.OUTPUT_FILE_NAME);
newBuildConfiguration.setSkipCompile(!oldConfiguration.DO_BUILD);
final ModifiableCompilerOptions newCompilerOptions = newBuildConfiguration.getCompilerOptions();
newCompilerOptions.setAllOptions(convertCompilerOptions(oldConfiguration, module, newCompilerOptions));
}
String outputFolder;
if (facet && oldConfiguration != null && oldConfiguration.USE_FACET_COMPILE_OUTPUT_PATH) {
outputFolder = PathUtil.getCanonicalPath(module.expandPath(oldConfiguration.FACET_COMPILE_OUTPUT_PATH));
}
else {
outputFolder = getOutputFolder(module);
}
newBuildConfiguration.setOutputFolder(outputFolder);
Collection<Element> orderEntriesToRemove = new ArrayList<>();
// TODO filter out java libraries and remove their order entries
for (Element orderEntry : module.getOrderEntries()) {
String orderEntryType = orderEntry.getAttributeValue(OrderEntryFactory.ORDER_ENTRY_TYPE_ATTR);
if (ModuleLibraryOrderEntryImpl.ENTRY_TYPE.equals(orderEntryType)) {
Element library = orderEntry.getChild(LibraryImpl.ELEMENT);
if (!isApplicableLibrary(library, s -> module.expandPath(s))) {
// ignore non-flex module library
orderEntriesToRemove.add(orderEntry);
continue;
}
if (facet && isAutogeneratedLibrary(library)) {
orderEntriesToRemove.add(orderEntry);
continue;
}
Element libraryProperties;
if (!usedModuleLibrariesEntries.add(orderEntry)) {
// this library is already used by another build configuration, create new entry with new library
Element newEntry = orderEntry.clone();
orderEntriesToAdd.add(newEntry);
library = orderEntry.getChild(LibraryImpl.ELEMENT);
libraryProperties = library.getChild(LibraryImpl.PROPERTIES_ELEMENT);
}
else {
library.setAttribute(LibraryImpl.LIBRARY_TYPE_ATTR, FlexLibraryType.FLEX_LIBRARY.getKindId());
libraryProperties = new Element(LibraryImpl.PROPERTIES_ELEMENT);
//noinspection unchecked
library.getChildren().add(0, libraryProperties);
}
String libraryId = FlexLibraryIdGenerator.generateId();
XmlSerializer.serializeInto(new FlexLibraryProperties(libraryId), libraryProperties);
ModifiableModuleLibraryEntry moduleLibraryEntry = ConversionHelper.createModuleLibraryEntry(libraryId);
convertDependencyType(orderEntry, moduleLibraryEntry.getDependencyType());
newBuildConfiguration.getDependencies().getModifiableEntries().add(moduleLibraryEntry);
}
else if ("library".equals(orderEntryType)) {
String libraryName = orderEntry.getAttributeValue("name");
String libraryLevel = orderEntry.getAttributeValue("level");
if (myParams.libraryExists(libraryName, libraryLevel)) {
myParams.changeLibraryTypeToFlex(libraryName, libraryLevel);
ModifiableSharedLibraryEntry sharedLibraryEntry = ConversionHelper.createSharedLibraryEntry(libraryName, libraryLevel);
convertDependencyType(orderEntry, sharedLibraryEntry.getDependencyType());
newBuildConfiguration.getDependencies().getModifiableEntries().add(sharedLibraryEntry);
}
else {
orderEntriesToRemove.add(orderEntry);
}
}
else if (ModuleOrderEntryImpl.ENTRY_TYPE.equals(orderEntryType)) {
String moduleName = orderEntry.getAttributeValue(ModuleOrderEntryImpl.MODULE_NAME_ATTR);
Collection<String> bcNames = myParams.getBcNamesForDependency(moduleName, newBuildConfiguration.getNature());
for (String bcName : bcNames) {
ModifiableBuildConfigurationEntry bcEntry = ConversionHelper.createBuildConfigurationEntry(moduleName, bcName);
convertDependencyType(orderEntry, bcEntry.getDependencyType());
newBuildConfiguration.getDependencies().getModifiableEntries().add(bcEntry);
}
if (bcNames.isEmpty()) {
orderEntriesToRemove.add(orderEntry);
}
}
else if (ModuleJdkOrderEntryImpl.ENTRY_TYPE.equals(orderEntryType)) {
if (!facet) {
String sdkName = orderEntry.getAttributeValue(ModuleJdkOrderEntryImpl.JDK_NAME_ATTR);
String newSdkName = processSdkEntry(newBuildConfiguration, oldConfiguration, sdkName);
ContainerUtil.addIfNotNull(usedSdksNames, newSdkName);
}
orderEntriesToRemove.add(orderEntry);
}
else if (InheritedJdkOrderEntryImpl.ENTRY_TYPE.equals(orderEntryType)) {
if (!facet) {
String newSdkName = processSdkEntry(newBuildConfiguration, oldConfiguration, myParams.projectSdkName);
ContainerUtil.addIfNotNull(usedSdksNames, newSdkName);
}
orderEntriesToRemove.add(orderEntry);
}
}
if (facetSdkName != null) {
String newSdkName = processSdkEntry(newBuildConfiguration, oldConfiguration, facetSdkName);
ContainerUtil.addIfNotNull(usedSdksNames, newSdkName);
}
if (!orderEntriesToRemove.isEmpty()) {
module.getOrderEntries().removeAll(orderEntriesToRemove);
}
if (BCUtils.canHaveRLMsAndRuntimeStylesheets(newBuildConfiguration) &&
oldConfiguration != null && !oldConfiguration.CSS_FILES_LIST.isEmpty()) {
final Collection<String> cssFilesToCompile = new ArrayList<>();
for (String cssPath : oldConfiguration.CSS_FILES_LIST) {
cssFilesToCompile.add(PathUtil.getCanonicalPath(module.expandPath(cssPath)));
}
newBuildConfiguration.setCssFilesToCompile(cssFilesToCompile);
}
}
public static boolean isAutogeneratedLibrary(Element libraryElement) {
String libraryName = libraryElement.getAttributeValue(LibraryImpl.LIBRARY_NAME_ATTR);
return libraryName != null && libraryName.startsWith("AUTOGENERATED library equal to Flex SDK ");
}
private static Map<String, String> convertCompilerOptions(final FlexBuildConfiguration oldConfig,
final ModuleSettings module,
final ModifiableCompilerOptions newCompilerOptions) {
if (oldConfig.USE_CUSTOM_CONFIG_FILE) {
final String customConfigFilePath = PathUtil.getCanonicalPath(module.expandPath(oldConfig.CUSTOM_CONFIG_FILE));
newCompilerOptions.setAdditionalConfigFilePath(customConfigFilePath);
}
// todo may be parse options, replace "-a b" to "-a=b", may be move some options to dedicated fields
newCompilerOptions.setAdditionalOptions(oldConfig.ADDITIONAL_COMPILER_OPTIONS);
final Map<String, String> options = new THashMap<>(newCompilerOptions.getAllOptions());
if (oldConfig.USE_LOCALE_SETTINGS) {
options.put("compiler.locale", oldConfig.LOCALE.replace(",", CompilerOptionInfo.LIST_ENTRIES_SEPARATOR));
}
if (!oldConfig.CONDITIONAL_COMPILATION_DEFINITION_LIST.isEmpty()) {
final StringBuilder b = new StringBuilder();
for (FlexBuildConfiguration.ConditionalCompilationDefinition def : oldConfig.CONDITIONAL_COMPILATION_DEFINITION_LIST) {
if (b.length() > 0) b.append(CompilerOptionInfo.LIST_ENTRIES_SEPARATOR);
b.append(def.NAME).append(CompilerOptionInfo.LIST_ENTRY_PARTS_SEPARATOR).append(def.VALUE);
}
options.put("compiler.define", b.toString());
}
if (!oldConfig.NAMESPACE_AND_MANIFEST_FILE_INFO_LIST.isEmpty()) {
final StringBuilder b = new StringBuilder();
for (FlexBuildConfiguration.NamespaceAndManifestFileInfo info : oldConfig.NAMESPACE_AND_MANIFEST_FILE_INFO_LIST) {
if (b.length() > 0) b.append(CompilerOptionInfo.LIST_ENTRIES_SEPARATOR);
b.append(info.NAMESPACE).append(CompilerOptionInfo.LIST_ENTRY_PARTS_SEPARATOR)
.append(PathUtil.getCanonicalPath(module.expandPath(info.MANIFEST_FILE_PATH)));
}
options.put("compiler.namespaces.namespace", b.toString());
}
if (!oldConfig.PATH_TO_SERVICES_CONFIG_XML.isEmpty()) {
options.put("compiler.services", oldConfig.PATH_TO_SERVICES_CONFIG_XML);
options.put("compiler.context-root", oldConfig.CONTEXT_ROOT);
}
return options;
}
static boolean isApplicableLibrary(final Element library, Function<String, String> pathExpander) {
String libraryType = library.getAttributeValue(LibraryImpl.LIBRARY_TYPE_ATTR);
if (FlexLibraryType.FLEX_LIBRARY.getKindId().equals(libraryType)) {
return true;
}
if (libraryType != null) {
return false; // ignore explicit non-Flex libraries
}
final Element rootChild = library.getChild(OrderRootType.CLASSES.name());
if (rootChild == null) {
return false; // corrupted element
}
JarDirectories jarDirectories = new JarDirectories();
try {
jarDirectories.readExternal(library);
}
catch (InvalidDataException ignored) {
jarDirectories.clear();
}
List<Element> classesRoots = rootChild.getChildren(LibraryImpl.ROOT_PATH_ELEMENT);
if (classesRoots.isEmpty()) {
// no classes root
return false;
}
for (Element root : classesRoots) {
final String url = root.getAttributeValue("url");
if (url == null) {
continue; // corrupted element
}
final String path = getPathFromUrl(url);
if (path == null) {
continue;
}
if (path.toLowerCase().endsWith(".swc")) {
return true;
}
else {
if (jarDirectories.contains(OrderRootType.CLASSES, url)) {
String expanded = pathExpander.fun(path);
File file = new File(expanded);
if (!file.isDirectory()) {
return true;
}
String[] allChildren = file.list();
if (allChildren == null || allChildren.length == 0) {
return true;
}
File[] swcs = file.listFiles(FileFilters.filesWithExtension("swc"));
if (swcs != null && swcs.length > 0) {
return true;
}
File[] jars = file.listFiles(FileFilters.filesWithExtension("jar"));
if (jars != null && jars.length > 0) {
continue;
}
return true;
}
else if (!path.toLowerCase().endsWith(".jar")) {
return true;
}
}
}
return false;
}
@Nullable
private static String getPathFromUrl(String url) {
if (url.startsWith(JarFileSystem.PROTOCOL_PREFIX) && url.endsWith(JarFileSystem.JAR_SEPARATOR)) {
return url.substring(JarFileSystem.PROTOCOL_PREFIX.length(), url.length() - JarFileSystem.JAR_SEPARATOR.length());
}
else if (url.startsWith(LocalFileSystem.PROTOCOL_PREFIX)) {
return url.substring(LocalFileSystem.PROTOCOL_PREFIX.length());
}
else {
LOG.warn("Unknown url type: " + url);
return null;
}
}
private static void convertDependencyType(Element orderEntry, ModifiableDependencyType dependencyType) {
DependencyScope scope = DependencyScope.readExternal(orderEntry);
boolean isExported = orderEntry.getAttribute(ModuleLibraryOrderEntryImpl.EXPORTED_ATTR) != null;
dependencyType.setLinkageType(FlexUtils.convertLinkageType(scope, isExported));
}
private static String getOutputFolder(final ModuleSettings moduleSettings) {
final Element rootManagerElement = moduleSettings.getComponentElement(ModuleSettings.MODULE_ROOT_MANAGER_COMPONENT);
if (rootManagerElement != null) {
final boolean inheritOutput = "true".equals(rootManagerElement.getAttributeValue(
JpsJavaModelSerializerExtension.INHERIT_COMPILER_OUTPUT_ATTRIBUTE));
if (!inheritOutput) {
final Element outputElement = rootManagerElement.getChild("output");
final String outputUrl = outputElement == null ? null : outputElement.getAttributeValue("url");
if (outputUrl != null) {
String path = PathUtil.getCanonicalPath(VfsUtilCore.urlToPath(moduleSettings.expandPath(outputUrl)));
return moduleSettings.collapsePath(path);
}
}
}
final String projectOutputUrl = moduleSettings.getProjectOutputUrl();
String path = projectOutputUrl == null ? "" :
VfsUtilCore.urlToPath(moduleSettings.expandPath(projectOutputUrl) +
"/" + CompilerModuleExtension.PRODUCTION + "/" + moduleSettings.getModuleName());
return moduleSettings.collapsePath(path);
}
/**
* @return SDK name if found
*/
@Nullable
private static String processSdkEntry(ModifiableFlexBuildConfiguration bc,
@Nullable FlexBuildConfiguration oldConfiguration,
String ideaSdkName) {
if (ideaSdkName == null) {
bc.setTargetPlatform(TargetPlatform.Web);
return null;
}
Sdk oldSdk = ProjectJdkTable.getInstance().findJdk(ideaSdkName);
final String sdkTypeName;
if (oldSdk == null ||
oldSdk.getHomePath() == null ||
!ArrayUtil.contains((sdkTypeName = oldSdk.getSdkType().getName()), ConversionParams.OLD_SDKS_TYPES)) {
bc.setTargetPlatform(TargetPlatform.Web);
return null;
}
if (ConversionParams.OLD_AIR_MOBIE_SDK_TYPE_NAME.equals(sdkTypeName)) {
bc.setTargetPlatform(TargetPlatform.Mobile);
if (bc.getOutputType() == OutputType.Application) {
bc.getAndroidPackagingOptions().setEnabled(true);
final String fileName = FileUtil.getNameWithoutExtension(bc.getOutputFileName());
bc.getAndroidPackagingOptions().setPackageFileName(fileName);
bc.getIosPackagingOptions().setPackageFileName(fileName);
}
}
else if (ConversionParams.OLD_AIR_SDK_TYPE_NAME.equals(sdkTypeName)) {
bc.setTargetPlatform(TargetPlatform.Desktop);
if (bc.getOutputType() == OutputType.Application) {
bc.getAirDesktopPackagingOptions().setPackageFileName(FileUtil.getNameWithoutExtension(bc.getOutputFileName()));
}
}
else {
bc.setTargetPlatform(TargetPlatform.Web);
final String targetPlayer = FlexSdkUtils.getTargetPlayer(oldConfiguration == null ? null :
oldConfiguration.TARGET_PLAYER_VERSION, oldSdk.getHomePath());
bc.getDependencies().setTargetPlayer(targetPlayer);
}
Sdk sdk = ConversionParams.findNewSdk(oldSdk.getHomePath());
if (sdk != null) {
SdkEntry sdkEntry = Factory.createSdkEntry(sdk.getName());
// TODO roots dependencies types
bc.getDependencies().setSdkEntry(sdkEntry);
return sdk.getName();
}
else {
return null;
}
}
private static void addContent(Element source, Element target) {
final List attributes = source.getAttributes();
for (Object attribute : attributes) {
target.setAttribute(((Attribute)attribute).clone());
}
for (Object child : source.getChildren()) {
target.addContent(((Element)child).clone());
}
}
public static String generateModuleBcName(ModuleSettings module) {
return module.getModuleName();
}
public static String generateFacetBcName(List<Element> facets, Element facet) {
// TODO cache names for module
List<String> names = FlexBuildConfigurationManagerImpl.generateUniqueNames(ContainerUtil.map(facets, element -> element.getAttributeValue(JpsFacetSerializer.NAME_ATTRIBUTE)));
return names.get(facets.indexOf(facet));
}
private static void readNamespaceAndManifestInfoList(final Element element,
final FlexBuildConfiguration oldConfig) throws InvalidDataException {
final List<FlexBuildConfiguration.NamespaceAndManifestFileInfo> namespaceAndManifestFileInfoList =
new ArrayList<>();
final Element namespaceAndManifestFileInfoListElement = element.getChild(NAMESPACE_AND_MANIFEST_FILE_INFO_LIST_ELEMENT_NAME);
if (namespaceAndManifestFileInfoListElement != null) {
for (final Object namespaceAndManifestFileInfoElement : namespaceAndManifestFileInfoListElement
.getChildren(FlexBuildConfiguration.NamespaceAndManifestFileInfo.class.getSimpleName())) {
final FlexBuildConfiguration.NamespaceAndManifestFileInfo
namespaceAndManifestFileInfo = new FlexBuildConfiguration.NamespaceAndManifestFileInfo();
DefaultJDOMExternalizer.readExternal(namespaceAndManifestFileInfo, (Element)namespaceAndManifestFileInfoElement);
namespaceAndManifestFileInfoList.add(namespaceAndManifestFileInfo);
}
}
oldConfig.NAMESPACE_AND_MANIFEST_FILE_INFO_LIST = namespaceAndManifestFileInfoList;
}
private static void readConditionalCompilerDefinitionList(final Element element,
final FlexBuildConfiguration oldConfig) throws InvalidDataException {
final List<FlexBuildConfiguration.ConditionalCompilationDefinition> conditionalCompilationDefinitionList =
new ArrayList<>();
final Element conditionalCompilerDefinitionListElement = element.getChild(CONDITIONAL_COMPILER_DEFINITION_LIST_ELEMENT_NAME);
if (conditionalCompilerDefinitionListElement != null) {
for (final Object conditionalCompilerDefinitionElement : conditionalCompilerDefinitionListElement
.getChildren(FlexBuildConfiguration.ConditionalCompilationDefinition.class.getSimpleName())) {
final FlexBuildConfiguration.ConditionalCompilationDefinition
conditionalCompilationDefinition = new FlexBuildConfiguration.ConditionalCompilationDefinition();
DefaultJDOMExternalizer.readExternal(conditionalCompilationDefinition, (Element)conditionalCompilerDefinitionElement);
conditionalCompilationDefinitionList.add(conditionalCompilationDefinition);
}
}
oldConfig.CONDITIONAL_COMPILATION_DEFINITION_LIST = conditionalCompilationDefinitionList;
}
private static void readCssFilesList(final Element element,
final FlexBuildConfiguration oldConfig) throws InvalidDataException {
final List<String> cssFilesList = new ArrayList<>();
final Element cssFilesListElement = element.getChild(CSS_FILES_LIST_ELEMENT_NAME);
if (cssFilesListElement != null) {
//noinspection unchecked
for (Element conditionalCompilerDefinitionElement : cssFilesListElement.getChildren(FILE_PATH_ELEMENT_NAME)) {
cssFilesList.add(conditionalCompilerDefinitionElement.getValue());
}
}
oldConfig.CSS_FILES_LIST = cssFilesList;
}
}