| /** |
| * Copyright (c) 2009-2010 Thales Corporate Services S.A.S. |
| * This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-v2.0 |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * Thales Corporate Services S.A.S - initial API and implementation |
| */ |
| package org.eclipse.egf.core.pde.tools; |
| |
| import java.lang.reflect.InvocationTargetException; |
| import java.net.URISyntaxException; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.core.resources.IContainer; |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IFolder; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IProjectDescription; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.core.runtime.SubMonitor; |
| import org.eclipse.egf.common.constant.EGFCommonConstants; |
| import org.eclipse.egf.common.helper.JavaHelper; |
| import org.eclipse.egf.common.l10n.EGFCommonMessages; |
| import org.eclipse.egf.core.helper.ProjectHelper; |
| import org.eclipse.egf.core.l10n.EGFCoreMessages; |
| import org.eclipse.egf.core.natures.EGFNatures; |
| import org.eclipse.egf.core.pde.EGFPDEPlugin; |
| import org.eclipse.emf.codegen.util.CodeGenUtil; |
| import org.eclipse.emf.common.util.URI; |
| import org.eclipse.emf.common.util.UniqueEList; |
| import org.eclipse.jdt.core.IClasspathEntry; |
| import org.eclipse.jdt.core.IJavaProject; |
| import org.eclipse.jdt.core.JavaCore; |
| import org.eclipse.jdt.core.JavaModelException; |
| import org.eclipse.jdt.launching.JavaRuntime; |
| import org.eclipse.pde.core.IBaseModel; |
| import org.eclipse.pde.core.build.IBuild; |
| import org.eclipse.pde.core.build.IBuildEntry; |
| import org.eclipse.pde.core.build.IBuildModel; |
| import org.eclipse.pde.core.plugin.IPluginBase; |
| import org.eclipse.pde.core.plugin.IPluginImport; |
| import org.eclipse.pde.core.plugin.IPluginLibrary; |
| import org.eclipse.pde.core.plugin.IPluginModelFactory; |
| import org.eclipse.pde.internal.core.ICoreConstants; |
| import org.eclipse.pde.internal.core.build.WorkspaceBuildModel; |
| import org.eclipse.pde.internal.core.bundle.WorkspaceBundlePluginModel; |
| import org.eclipse.pde.internal.core.ibundle.IBundle; |
| import org.eclipse.pde.internal.core.ibundle.IBundlePluginModelBase; |
| import org.eclipse.pde.internal.core.ibundle.IManifestHeader; |
| import org.eclipse.pde.internal.core.natures.PDE; |
| import org.eclipse.pde.internal.core.text.bundle.BundleSymbolicNameHeader; |
| import org.eclipse.pde.internal.ui.util.ModelModification; |
| import org.eclipse.pde.internal.ui.util.PDEModelUtility; |
| import org.eclipse.pde.internal.ui.wizards.tools.OrganizeManifest; |
| import org.eclipse.ui.actions.WorkspaceModifyOperation; |
| import org.osgi.framework.Constants; |
| import org.osgi.framework.Version; |
| |
| /** |
| * Operation to convert a simple project or a bundle into an EGF java bundle |
| * project if necessary |
| */ |
| public class ConvertProjectOperation extends WorkspaceModifyOperation { |
| |
| private static final String DEFAULT_LIBRARY = EGFCommonConstants.DOT_STRING; |
| |
| private IProject _project; |
| |
| private boolean createJavaProject; |
| |
| private boolean addEGFNature; |
| |
| private final List<String> sourceFolders = new UniqueEList<String>(); |
| |
| private final List<String> outputFolders = new UniqueEList<String>(); |
| |
| private final List<String> libraries = new UniqueEList<String>(); |
| |
| private final List<String> directories = new UniqueEList<String>(); |
| |
| private final List<IClasspathEntry> classpathEntries = new UniqueEList<IClasspathEntry>(); |
| |
| private String[] initialSourceFolders; |
| private String[] initialDependencies; |
| |
| /** |
| * Workspace operation to convert the specified project into a plug-in |
| * project. |
| * |
| * @param project |
| * The project to be converted in a Bundle |
| * @param createJavaProject |
| * The project should be converted to a JavaProject |
| * @param addEGFNature |
| * The project should have en EGF Nature. |
| */ |
| public ConvertProjectOperation(IProject project, boolean createJavaProject, boolean addEGFNature) { |
| _project = project; |
| this.createJavaProject = createJavaProject; |
| this.addEGFNature = addEGFNature; |
| } |
| |
| public static String getValidId(String projectName) { |
| String name = projectName.replaceAll("[^a-zA-Z0-9\\._]", "_"); //$NON-NLS-1$ //$NON-NLS-2$ |
| // . is illegal as a first character |
| if (name != null && name.startsWith(".")) { //$NON-NLS-1$ |
| return name.substring(1, name.length()); |
| } |
| return name; |
| } |
| |
| /** |
| * Convert a project |
| * |
| * @param monitor |
| * Progress monitor |
| */ |
| |
| @Override |
| protected void execute(IProgressMonitor monitor) throws CoreException, InvocationTargetException, InterruptedException { |
| |
| SubMonitor subMonitor = SubMonitor.convert(monitor, EGFCoreMessages.ConvertProjectOperation_converter, 1000); |
| |
| boolean hasPluginNature = false; |
| boolean hasJavaNature = false; |
| |
| // Do early checks to make sure we can get out fast if we're not setup |
| // properly |
| if (_project == null || _project.exists() == false) { |
| return; |
| } |
| |
| // Build an EMF URI Style |
| URI projectLocationURI = URI.createFileURI(_project.getFullPath().toOSString()); |
| |
| // Nature |
| List<String> requiredNatures = new ArrayList<String>(); |
| List<String> requiredBuilders = new ArrayList<String>(); |
| |
| if (_project.hasNature(EGFNatures.EGF_NATURE)) { |
| requiredBuilders.add(EGFNatures.PATTERN_BUILDER_ID); |
| } else if (addEGFNature) { |
| requiredNatures.add(EGFNatures.EGF_NATURE); |
| requiredBuilders.add(EGFNatures.PATTERN_BUILDER_ID); |
| } |
| |
| if (_project.hasNature(PDE.PLUGIN_NATURE)) { |
| hasPluginNature = true; |
| } else |
| requiredNatures.add(PDE.PLUGIN_NATURE); |
| requiredBuilders.add(PDE.MANIFEST_BUILDER_ID); |
| requiredBuilders.add(PDE.SCHEMA_BUILDER_ID); |
| |
| if (_project.hasNature(JavaCore.NATURE_ID)) { |
| hasJavaNature = true; |
| IJavaProject javaProject = null; |
| try { |
| javaProject = JavaCore.create(_project); |
| classpathEntries.addAll(Arrays.asList(javaProject.getRawClasspath())); |
| for (String outputFolder : JavaHelper.getStringOutputFolders(javaProject)) { |
| outputFolders.add(outputFolder + EGFCommonConstants.SLASH_CHARACTER); |
| } |
| } finally { |
| if (javaProject != null) { |
| javaProject.close(); |
| } |
| } |
| requiredBuilders.add(JavaCore.BUILDER_ID); |
| } else if (createJavaProject) { |
| requiredNatures.add(JavaCore.NATURE_ID); |
| requiredBuilders.add(JavaCore.BUILDER_ID); |
| } |
| // Create Project Description if necessary |
| IProjectDescription projectDescription = null; |
| if (_project.exists()) { |
| projectDescription = _project.getDescription(); |
| subMonitor.worked(100); |
| } else { |
| projectDescription = ResourcesPlugin.getWorkspace().newProjectDescription(_project.getName()); |
| if (projectLocationURI != null) { |
| try { |
| projectDescription.setLocationURI(new java.net.URI(projectLocationURI.toString())); |
| } catch (URISyntaxException use) { |
| throw new CoreException(EGFPDEPlugin.getDefault().newStatus(IStatus.ERROR, EGFCommonMessages.Exception_unexpectedException, use)); |
| } |
| } |
| _project.create(projectDescription, subMonitor.newChild(100, SubMonitor.SUPPRESS_NONE)); |
| } |
| |
| // Nature setup |
| if (projectDescription.getNatureIds() == null) { |
| projectDescription.setNatureIds(requiredNatures.toArray(new String[requiredNatures.size()])); |
| subMonitor.worked(200); |
| } else |
| ProjectHelper.addNatures(projectDescription, requiredNatures, subMonitor.newChild(100, SubMonitor.SUPPRESS_NONE)); |
| |
| ProjectHelper.addBuilders(projectDescription, requiredBuilders, subMonitor.newChild(100, SubMonitor.SUPPRESS_NONE)); |
| |
| // Set Project Description |
| _project.setDescription(projectDescription, subMonitor.newChild(100, SubMonitor.SUPPRESS_NONE)); |
| |
| setupEntries(monitor, hasJavaNature || createJavaProject); |
| |
| // Manifest |
| if (hasPluginNature && _project.getFile(ICoreConstants.BUNDLE_FILENAME_DESCRIPTOR).exists()) { |
| updateManifestFile(subMonitor.newChild(100, SubMonitor.SUPPRESS_NONE)); |
| } else { |
| createManifestFile(_project.getFile(ICoreConstants.BUNDLE_FILENAME_DESCRIPTOR), subMonitor.newChild(100, SubMonitor.SUPPRESS_NONE)); |
| } |
| |
| // build.properties |
| if (hasPluginNature && _project.getFile(ICoreConstants.BUILD_FILENAME_DESCRIPTOR).exists()) { |
| updateBuildFile(subMonitor.newChild(100, SubMonitor.SUPPRESS_NONE)); |
| } else { |
| createBuildFile(_project.getFile(ICoreConstants.BUILD_FILENAME_DESCRIPTOR), subMonitor.newChild(100, SubMonitor.SUPPRESS_NONE)); |
| } |
| |
| } |
| |
| private void setupEntries(IProgressMonitor monitor, boolean isJavaProject) throws CoreException { |
| |
| SubMonitor subMonitor = SubMonitor.convert(monitor, EGFCoreMessages.ConvertProjectOperation_setupClasspath, 400); |
| |
| // Current variables |
| boolean isInitiallyEmpty = classpathEntries.isEmpty(); |
| boolean hasRequiredPluginsContainer = false; |
| |
| // Classpath analysis |
| for (IClasspathEntry currentClassPath : classpathEntries) { |
| switch (currentClassPath.getEntryKind()) { |
| case IClasspathEntry.CPE_SOURCE: |
| // Process existing source folder |
| String relativePath = getRelativePath(currentClassPath, _project); |
| // Create a src source folder if none |
| if (EGFCommonConstants.EMPTY_STRING.equals(relativePath)) { |
| IPath src = new Path("src"); //$NON-NLS-1$ |
| IContainer sourceContainer = _project.getFolder(src); |
| if (sourceContainer.exists() == false) { |
| ((IFolder) sourceContainer).create(false, true, subMonitor.newChild(100, SubMonitor.SUPPRESS_NONE)); |
| } |
| sourceFolders.add(src.toString() + EGFCommonConstants.SLASH_CHARACTER); |
| IClasspathEntry sourceClasspathEntry = JavaCore.newSourceEntry(sourceContainer.getFullPath()); |
| for (Iterator<IClasspathEntry> i = classpathEntries.iterator(); i.hasNext();) { |
| IClasspathEntry classpathEntry = i.next(); |
| if (classpathEntry.getPath().isPrefixOf(sourceContainer.getFullPath())) { |
| // Remove previous source folder if any |
| i.remove(); |
| } |
| } |
| classpathEntries.add(0, sourceClasspathEntry); |
| } else { |
| sourceFolders.add(relativePath + EGFCommonConstants.SLASH_CHARACTER); |
| } |
| break; |
| case IClasspathEntry.CPE_LIBRARY: |
| // Process existing library |
| String path = getRelativePath(currentClassPath, _project); |
| if (path.length() > 0) |
| libraries.add(path); |
| else |
| libraries.add(EGFCommonConstants.DOT_STRING); |
| break; |
| case IClasspathEntry.CPE_CONTAINER: |
| hasRequiredPluginsContainer = EGFCommonConstants.REQUIRED_PLUGINS_CLASSPATH_CONTAINER.equals(currentClassPath.getPath().toString()); |
| break; |
| } |
| } |
| subMonitor.worked(100); |
| |
| // Create source folders if necessary |
| if (isJavaProject && initialSourceFolders != null) { |
| for (String sourceFolder : initialSourceFolders) { |
| IPath src = new Path(sourceFolder); |
| IContainer sourceContainer = _project.getFolder(src); |
| // Create folder if it doesn't exist |
| if (sourceContainer.exists() == false) { |
| ((IFolder) sourceContainer).create(false, true, subMonitor.newChild(100, SubMonitor.SUPPRESS_NONE)); |
| } |
| // Classpath processing |
| sourceFolders.add(src.toString() + EGFCommonConstants.SLASH_CHARACTER); |
| IClasspathEntry sourceClasspathEntry = JavaCore.newSourceEntry(sourceContainer.getFullPath()); |
| for (Iterator<IClasspathEntry> i = classpathEntries.iterator(); i.hasNext();) { |
| IClasspathEntry classpathEntry = i.next(); |
| if (classpathEntry.getPath().isPrefixOf(sourceContainer.getFullPath())) { |
| // Remove previous source folder if any |
| i.remove(); |
| } |
| } |
| classpathEntries.add(0, sourceClasspathEntry); |
| } |
| } else { |
| subMonitor.worked(100); |
| } |
| |
| // Folder analysis |
| for (IResource resource : _project.members()) { |
| if (resource instanceof IContainer) { |
| String path = resource.getFullPath().removeFirstSegments(1).toString() + EGFCommonConstants.SLASH_CHARACTER; |
| // Ignore directories who are either a source folder, an output |
| // folder or a directory who starts with a dot |
| if (sourceFolders.contains(path) == false && outputFolders.contains(path) == false && path.startsWith(EGFCommonConstants.DOT_STRING) == false) { |
| directories.add(path); |
| } |
| } |
| } |
| |
| // Finally setup classpath if necessary |
| if (isJavaProject) { |
| try { |
| // Process JRE if necessary |
| if (isInitiallyEmpty) { |
| IClasspathEntry jreClasspathEntry = JavaCore.newVariableEntry(new Path(JavaRuntime.JRELIB_VARIABLE), new Path(JavaRuntime.JRESRC_VARIABLE), new Path(JavaRuntime.JRESRCROOT_VARIABLE)); |
| for (Iterator<IClasspathEntry> i = classpathEntries.iterator(); i.hasNext();) { |
| IClasspathEntry classpathEntry = i.next(); |
| if (classpathEntry.getPath().isPrefixOf(jreClasspathEntry.getPath())) { |
| i.remove(); |
| } |
| } |
| String jreContainer = JavaRuntime.JRE_CONTAINER; |
| String complianceLevel = CodeGenUtil.EclipseUtil.getJavaComplianceLevel(_project); |
| if (JavaCore.VERSION_1_5.equals(complianceLevel)) { |
| jreContainer += "/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"; //$NON-NLS-1$ |
| } else if (JavaCore.VERSION_1_6.equals(complianceLevel)) { |
| jreContainer += "/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"; //$NON-NLS-1$ |
| } else if (JavaCore.VERSION_1_7.equals(complianceLevel)) { |
| jreContainer += "/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"; //$NON-NLS-1$ |
| } |
| classpathEntries.add(JavaCore.newContainerEntry(new Path(jreContainer))); |
| } |
| // Process Required Plugins Container if necessary |
| if (hasRequiredPluginsContainer == false) { |
| classpathEntries.add(JavaCore.newContainerEntry(new Path(EGFCommonConstants.REQUIRED_PLUGINS_CLASSPATH_CONTAINER))); |
| } |
| // Classpath setup |
| IJavaProject javaProject = null; |
| try { |
| javaProject = JavaCore.create(_project); |
| javaProject.setRawClasspath(classpathEntries.toArray(new IClasspathEntry[classpathEntries.size()]), subMonitor.newChild(100, SubMonitor.SUPPRESS_NONE)); |
| } finally { |
| if (javaProject != null) { |
| javaProject.close(); |
| } |
| } |
| } catch (JavaModelException jme) { |
| throw new CoreException(EGFPDEPlugin.getDefault().newStatus(IStatus.ERROR, EGFCommonMessages.Exception_unexpectedException, jme)); |
| } |
| } else { |
| subMonitor.worked(100); |
| } |
| |
| } |
| |
| private String getRelativePath(IClasspathEntry classpathEntry, IProject project) { |
| return project.getFile(classpathEntry.getPath()).getProjectRelativePath().removeFirstSegments(1).toString(); |
| } |
| |
| private void organizeExports(IProgressMonitor monitor) { |
| PDEModelUtility.modifyModel(new ModelModification(_project.getFile(ICoreConstants.BUNDLE_FILENAME_DESCRIPTOR)) { |
| |
| @Override |
| protected void modifyModel(IBaseModel model, IProgressMonitor innerMonitor) throws CoreException { |
| SubMonitor.convert(innerMonitor, EGFCoreMessages.ConvertProjectOperation_organizeExport, 100); |
| if (model instanceof IBundlePluginModelBase == false) { |
| return; |
| } |
| OrganizeManifest.organizeExportPackages(((IBundlePluginModelBase) model).getBundleModel().getBundle(), _project, true, true); |
| } |
| }, monitor); |
| } |
| |
| protected String createInitialName(String id) { |
| int loc = id.lastIndexOf(EGFCommonConstants.DOT_STRING); |
| if (loc == -1) { |
| return id; |
| } |
| StringBuffer buf = new StringBuffer(id.substring(loc + 1)); |
| buf.setCharAt(0, Character.toUpperCase(buf.charAt(0))); |
| return buf.toString(); |
| } |
| |
| private void createBuildFile(IFile file, IProgressMonitor monitor) throws CoreException { |
| SubMonitor.convert(monitor, EGFCoreMessages.ConvertProjectOperation_setupBuildfile, 100); |
| if (file.exists() == false) { |
| WorkspaceBuildModel model = new WorkspaceBuildModel(file); |
| manageBuildFile(model); |
| model.save(); |
| } |
| } |
| |
| private void updateBuildFile(IProgressMonitor monitor) { |
| PDEModelUtility.modifyModel(new ModelModification(_project.getFile(ICoreConstants.BUILD_FILENAME_DESCRIPTOR)) { |
| |
| @Override |
| protected void modifyModel(IBaseModel base, IProgressMonitor innerMonitor) throws CoreException { |
| SubMonitor.convert(innerMonitor, EGFCoreMessages.ConvertProjectOperation_setupBuildfile, 100); |
| if (base instanceof IBuildModel == false) { |
| return; |
| } |
| manageBuildFile((IBuildModel) base); |
| } |
| |
| }, monitor); |
| } |
| |
| protected void processFolders(IBuildModel model, String prefix, List<String> folders) throws CoreException { |
| IBuild build = model.getBuild(); |
| List<String> defaultFolders = new UniqueEList<String>(folders); |
| // Filter already assigned folders if any |
| for (IBuildEntry entry : build.getBuildEntries()) { |
| // Ignore non jar prefix or default library if any |
| if (entry.getName().startsWith(prefix) == false || entry.getName().equals(prefix + DEFAULT_LIBRARY)) { |
| continue; |
| } |
| // detect empty folders |
| boolean hasFolders = false; |
| // Filter tokens |
| for (String token : entry.getTokens()) { |
| hasFolders = defaultFolders.remove(token); |
| } |
| // Remove useless entry |
| if (hasFolders == false) { |
| build.remove(entry); |
| } |
| } |
| // Retrieve default |
| IBuildEntry entry = build.getEntry(prefix + DEFAULT_LIBRARY); |
| // Process remaining folders in default library |
| if (defaultFolders.size() > 0) { |
| // Create if necessary |
| if (entry == null) { |
| entry = model.getFactory().createEntry(prefix + DEFAULT_LIBRARY); |
| build.add(entry); |
| } |
| // Add remaining folders |
| for (String folder : defaultFolders) { |
| addToken(entry, folder); |
| } |
| } else if (entry != null) { |
| // Remove useless entry |
| build.remove(entry); |
| } |
| } |
| |
| protected void manageBuildFile(IBuildModel model) throws CoreException { |
| IBuild build = model.getBuild(); |
| // source |
| processFolders(model, IBuildEntry.JAR_PREFIX, sourceFolders); |
| // output |
| processFolders(model, IBuildEntry.OUTPUT_PREFIX, outputFolders); |
| // bin.includes |
| IBuildEntry binIncludesEntry = build.getEntry(IBuildEntry.BIN_INCLUDES); |
| boolean newBinIncludesEntry = false; |
| // Create if necessary |
| if (binIncludesEntry == null) { |
| newBinIncludesEntry = true; |
| binIncludesEntry = model.getFactory().createEntry(IBuildEntry.BIN_INCLUDES); |
| } |
| if (_project.getFile(ICoreConstants.PLUGIN_FILENAME_DESCRIPTOR).exists()) { |
| addToken(binIncludesEntry, ICoreConstants.PLUGIN_FILENAME_DESCRIPTOR); |
| } |
| if (_project.getFile(EGFCommonConstants.PLUGIN_PROPERTIES_DESCRIPTOR).exists()) { |
| addToken(binIncludesEntry, EGFCommonConstants.PLUGIN_PROPERTIES_DESCRIPTOR); |
| } |
| if (_project.getFile(ICoreConstants.BUNDLE_FILENAME_DESCRIPTOR).exists()) { |
| addToken(binIncludesEntry, EGFCommonConstants.BUNDLE_FILENAME_DIRECTORY_DESCRIPTOR); |
| } |
| // About.html in bin includes (eclipse EPL open source project |
| // convention) |
| if (_project.getFile(EGFCommonConstants.ABOUT_HTML_DESCRIPTOR).exists()) { |
| addToken(binIncludesEntry, EGFCommonConstants.ABOUT_HTML_DESCRIPTOR); |
| } |
| for (String directory : directories) { |
| addToken(binIncludesEntry, directory); |
| } |
| for (String library : libraries) { |
| addToken(binIncludesEntry, library); |
| } |
| if (sourceFolders.size() > 0) { |
| addToken(binIncludesEntry, DEFAULT_LIBRARY); |
| } |
| if (newBinIncludesEntry && binIncludesEntry.getTokens().length > 0) { |
| // add it to build model if necessary |
| build.add(binIncludesEntry); |
| } else if (binIncludesEntry.getTokens().length == 0) { |
| // remove it from build model if necessary |
| build.remove(binIncludesEntry); |
| } |
| // src.includes |
| IBuildEntry srcIncludesEntry = build.getEntry(IBuildEntry.SRC_INCLUDES); |
| boolean newSrcIncludesEntry = false; |
| // Create if necessary |
| if (srcIncludesEntry == null) { |
| newSrcIncludesEntry = true; |
| srcIncludesEntry = model.getFactory().createEntry(IBuildEntry.SRC_INCLUDES); |
| } |
| // About.html in src includes (eclipse EPL open source project |
| // convention) |
| if (_project.getFile(EGFCommonConstants.ABOUT_HTML_DESCRIPTOR).exists()) { |
| addToken(srcIncludesEntry, EGFCommonConstants.ABOUT_HTML_DESCRIPTOR); |
| } |
| if (newSrcIncludesEntry && srcIncludesEntry.getTokens().length > 0) { |
| // add it to build model if necessary |
| build.add(srcIncludesEntry); |
| } else if (srcIncludesEntry.getTokens().length == 0) { |
| // remove it from build model if necessary |
| build.remove(srcIncludesEntry); |
| } |
| } |
| |
| protected void addToken(IBuildEntry entry, String descriptor) throws CoreException { |
| boolean found = false; |
| for (String token : entry.getTokens()) { |
| if (token.equals(descriptor)) { |
| found = true; |
| break; |
| } |
| } |
| if (found == false) { |
| entry.addToken(descriptor); |
| } |
| } |
| |
| private void createManifestFile(IFile file, IProgressMonitor monitor) throws CoreException { |
| SubMonitor subMonitor = SubMonitor.convert(monitor, EGFCoreMessages.ConvertProjectOperation_setupManifestfile, 200); |
| WorkspaceBundlePluginModel model = new WorkspaceBundlePluginModel(file, null); |
| model.load(); |
| manageManifestFile(model); |
| model.save(); |
| subMonitor.worked(100); |
| organizeExports(subMonitor.newChild(100, SubMonitor.SUPPRESS_NONE)); |
| } |
| |
| private void updateManifestFile(IProgressMonitor monitor) { |
| PDEModelUtility.modifyModel(new ModelModification(_project.getFile(ICoreConstants.BUNDLE_FILENAME_DESCRIPTOR)) { |
| |
| @Override |
| protected void modifyModel(IBaseModel model, IProgressMonitor innerMonitor) throws CoreException { |
| SubMonitor subMonitor = SubMonitor.convert(innerMonitor, EGFCoreMessages.ConvertProjectOperation_setupManifestfile, 200); |
| if (model instanceof IBundlePluginModelBase == false) { |
| return; |
| } |
| manageManifestFile((IBundlePluginModelBase) model); |
| subMonitor.worked(100); |
| OrganizeManifest.organizeExportPackages(((IBundlePluginModelBase) model).getBundleModel().getBundle(), _project, true, true); |
| } |
| |
| }, monitor); |
| } |
| |
| protected void manageManifestFile(IBundlePluginModelBase model) throws CoreException { |
| |
| IBundle bundle = model.getBundleModel().getBundle(); |
| |
| String pluginId = bundle.getHeader(Constants.BUNDLE_SYMBOLICNAME); |
| String pluginName = bundle.getHeader(Constants.BUNDLE_NAME); |
| String pluginVersion = bundle.getHeader(Constants.BUNDLE_VERSION); |
| String complianceLevel = bundle.getHeader(Constants.BUNDLE_REQUIREDEXECUTIONENVIRONMENT); |
| |
| // Strip singleton keyword to avoid redundancy |
| if (pluginId != null && pluginId.indexOf(';') != -1) { |
| pluginId = pluginId.substring(0, pluginId.indexOf(';')); |
| } |
| |
| // Avoid empty string |
| if (pluginId != null && pluginId.trim().length() == 0) { |
| pluginId = null; |
| } |
| |
| boolean missingInfo = (pluginId == null || pluginName == null || pluginVersion == null); |
| |
| // If no ID exists, create one |
| if (pluginId == null) { |
| pluginId = getValidId(_project.getName()); |
| } |
| // At this point, the plug-in ID is not null |
| |
| // Process Version |
| processManifestVersion(model); |
| |
| // If no name exists, create one using the non-null pluginID |
| if (pluginName == null) { |
| pluginName = createInitialName(pluginId); |
| } |
| // Bundle Name |
| bundle.setHeader(Constants.BUNDLE_NAME, pluginName); |
| |
| // Bundle Symbolic Name |
| IManifestHeader header = bundle.getManifestHeader(Constants.BUNDLE_SYMBOLICNAME); |
| if (header != null && header instanceof BundleSymbolicNameHeader) { |
| BundleSymbolicNameHeader symbolic = (BundleSymbolicNameHeader) header; |
| if (symbolic.getId() == null || symbolic.getId().trim().length() == 0) { |
| symbolic.setId(pluginId); |
| } |
| // This will clean the header if multiple singleton exists |
| // If multiple singleton exists like |
| // ;singleton:=true;singleton:=true |
| // PDE is broken, typically the Plug-in Dependencies classpath |
| // container is missing |
| // and/or the plugin.xml could display a message like |
| // 'A plug-in manifest must contain at least one extension or |
| // extension point' |
| bundle.setHeader(Constants.BUNDLE_SYMBOLICNAME, pluginId + ";singleton:=true"); //$NON-NLS-1$ |
| } else { |
| bundle.setHeader(Constants.BUNDLE_SYMBOLICNAME, pluginId + ";singleton:=true"); //$NON-NLS-1$ |
| } |
| |
| if (complianceLevel == null && createJavaProject) { |
| complianceLevel = CodeGenUtil.EclipseUtil.getJavaComplianceLevel(_project); |
| if (JavaCore.VERSION_1_5.equals(complianceLevel)) { |
| bundle.setHeader(Constants.BUNDLE_REQUIREDEXECUTIONENVIRONMENT, "J2SE-1.5"); //$NON-NLS-1$ |
| } else if (JavaCore.VERSION_1_6.equals(complianceLevel)) { |
| bundle.setHeader(Constants.BUNDLE_REQUIREDEXECUTIONENVIRONMENT, "JavaSE-1.6"); //$NON-NLS-1$ |
| } else if (JavaCore.VERSION_1_7.equals(complianceLevel)) { |
| bundle.setHeader(Constants.BUNDLE_REQUIREDEXECUTIONENVIRONMENT, "JavaSE-1.7"); //$NON-NLS-1$ |
| } |
| } |
| |
| IPluginModelFactory factory = model.getPluginFactory(); |
| IPluginBase base = model.getPluginBase(); |
| |
| if (missingInfo) { |
| for (String library : libraries) { |
| IPluginLibrary pluginLibrary = factory.createLibrary(); |
| pluginLibrary.setName(library); |
| pluginLibrary.setExported(true); |
| base.add(pluginLibrary); |
| } |
| bundle.setHeader(Constants.BUNDLE_MANIFESTVERSION, "2"); //$NON-NLS-1$ |
| } |
| |
| // Add Dependencies |
| if (createJavaProject && initialDependencies != null) { |
| LOOP: for (String dependency : initialDependencies) { |
| if (base.getImports() != null) { |
| for (IPluginImport plugin : base.getImports()) { |
| if (plugin.getId().equals(dependency)) { |
| continue LOOP; |
| } |
| } |
| } |
| // At this stage dependency is not found, create one |
| IPluginImport plugin = factory.createImport(); |
| plugin.setId(dependency); |
| plugin.setName(dependency); |
| plugin.setReexported(true); |
| base.add(plugin); |
| } |
| } |
| |
| } |
| |
| protected void processManifestVersion(IBundlePluginModelBase model) { |
| // Locate Bundle |
| IBundle bundle = model.getBundleModel().getBundle(); |
| // Locate Version |
| String pluginVersion = bundle.getHeader(Constants.BUNDLE_VERSION); |
| // Process Version |
| if (pluginVersion == null) { |
| pluginVersion = "0.1.0.qualifier"; //$NON-NLS-1$ |
| } else { |
| Version version = Version.parseVersion(pluginVersion); |
| String major = version.getMajor() != 0 ? Integer.toString(version.getMajor()) : "0"; //$NON-NLS-1$ |
| String minor = version.getMinor() != 0 ? Integer.toString(version.getMinor()) : "1"; //$NON-NLS-1$ |
| String micro = version.getMicro() != 0 ? Integer.toString(version.getMicro()) : "0"; //$NON-NLS-1$ |
| String qualifier = version.getQualifier() != null && version.getQualifier().trim().length() != 0 ? version.getQualifier() : "qualifier"; //$NON-NLS-1$ |
| pluginVersion = major + "." + minor + "." + micro + "." + qualifier; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| } |
| bundle.setHeader(Constants.BUNDLE_VERSION, pluginVersion); |
| } |
| |
| public void setInitialSourceFolders(String[] initialSourceFolders) { |
| this.initialSourceFolders = initialSourceFolders; |
| } |
| |
| public void setInitialDependencies(String[] initialDependencies) { |
| this.initialDependencies = initialDependencies; |
| } |
| |
| } |