org.eclipse.tea.library.build/src/org/eclipse/tea/library/build/model/ManifestHolder.java - gerrit/tea/tea - Git at Google

 /*******************************************************************************
  *  Copyright (c) 2017 SSI Schaefer IT Solutions GmbH and others.
  *  All rights reserved. This program and the accompanying materials
  *  are made available under the terms of the Eclipse Public License v1.0
  *  which accompanies this distribution, and is available at
  *  http://www.eclipse.org/legal/epl-v10.html
  *
  *  Contributors:
  *      SSI Schaefer IT Solutions GmbH
  *******************************************************************************/
 package org.eclipse.tea.library.build.model;

 import static org.eclipse.tea.library.build.model.BundleData.splitList;

 import java.io.File;
 import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.LineNumberReader;
 import java.io.Writer;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
 import java.util.TreeMap;
 import java.util.jar.Attributes;
 import java.util.jar.Manifest;

 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.tea.library.build.internal.Activator;

 /**
  * Abstraction of the famous {@code MANIFEST.MF} file.
  * <p>
  * Supports manipulation of the manifest whilst keeping track of the order of
  * headers.
  */
 final class ManifestHolder {

 	private static final ParameterValue[] EMPTY_VALUES = {};

 	private final Map<String, ManifestAttribute> attributes = new TreeMap<>();
 	private final File referenceFile;

 	private ManifestHolder(final Manifest manifest, final File referenceFile) {
 		final Attributes attr = manifest.getMainAttributes();
 		for (Object key : attr.keySet()) {
 			final String name = key.toString();
 			final String[] values = splitList(attr, name);
 			attributes.put(name, new ManifestAttribute(name, values));
 		}

 		this.referenceFile = referenceFile;
 	}

 	static ManifestHolder fromManifest(Manifest manifest, File manifestFile) {
 		if (manifest == null) {
 			return null;
 		}
 		return new ManifestHolder(manifest, manifestFile);
 	}

 	/**
 	 * Returns the value list to which the specified key is mapped, or
 	 * {@code null} if this map contains no mapping for the key.
 	 */
 	private ParameterValue[] getValues(String key) {
 		ManifestAttribute attr = attributes.get(key);
 		if (attr == null) {
 			return null;
 		}
 		return attr.values;
 	}

 	private ParameterValue[] safeList(String name) {
 		ParameterValue[] result = getValues(name);
 		if (result == null) {
 			return EMPTY_VALUES;
 		}
 		return result;
 	}

 	ParameterValue[] getListAttribute(String name) {
 		return safeList(name);
 	}

 	ParameterValue getSingleAttribute(String name) {
 		return firstValue(name);
 	}

 	/**
 	 * Returns the first parameter value to which the specified key is mapped,
 	 * or {@code null} if this map contains no mapping for the key or there are
 	 * no values.
 	 */
 	private ParameterValue firstValue(String key) {
 		ParameterValue[] result = getValues(key);
 		if (result == null || result.length < 1) {
 			return null;
 		}
 		return result[0];
 	}

 	private String[] safeValueList(String name) {
 		ParameterValue[] result = getValues(name);
 		if (result == null) {
 			return BundleData.EMPTY_STRINGS;
 		}
 		return ParameterValue.valuesFromList(result);
 	}

 	private String getSimple(String name) {
 		ParameterValue pv = firstValue(name);
 		if (pv == null) {
 			return null;
 		}
 		return pv.getValue();
 	}

 	private boolean getBoolean(String name) {
 		return Boolean.parseBoolean(getSimple(name));
 	}

 	private void putSimple(String name, String value) {
 		attributes.put(name, new ManifestAttribute(name, value));
 	}

 	private void putList(String name, String[] values) {
 		attributes.put(name, new ManifestAttribute(name, values));
 	}

 	private void putList(String name, ParameterValue[] values) {
 		attributes.put(name, new ManifestAttribute(name, values));
 	}

 	ParameterValue getSymbolicName() {
 		return firstValue("Bundle-SymbolicName");
 	}

 	String getDescription() {
 		return getSimple("Bundle-Name");
 	}

 	String getActivator() {
 		return getSimple("Bundle-Activator");
 	}

 	void setActivator(String activator) {
 		if (activator == null) {
 			attributes.remove("Bundle-Activator");
 		} else {
 			putSimple("Bundle-Activator", activator);
 		}
 	}

 	void addDependency(String pluginName, boolean optional) {
 		ManifestAttribute reqBundleAttr = attributes.get("Require-Bundle");
 		ParameterValue[] dependencies = reqBundleAttr.values;
 		ParameterValue[] newDependecies = new ParameterValue[dependencies.length + 1];
 		System.arraycopy(dependencies, 0, newDependecies, 0, dependencies.length);

 		String param = optional ? ";resolution:=optional" : "";
 		newDependecies[newDependecies.length - 1] = new ParameterValue(pluginName + param);

 		ManifestAttribute manifestAttr = new ManifestAttribute("Require-Bundle", newDependecies);
 		attributes.put("Require-Bundle", manifestAttr);
 	}

 	ParameterValue[] getDependencies() {
 		return safeList("Require-Bundle");
 	}

 	ParameterValue[] getMavenDependencies() {
 		if (attributes.containsKey("WAMAS-Build-Maven")) {
 			// DEPRECATED
 			return safeList("WAMAS-Build-Maven");
 		}
 		return safeList("Build-Maven");
 	}

 	ParameterValue[] getImportPackages() {
 		return safeList("Import-Package");
 	}

 	ParameterValue[] getExportPackages() {
 		return safeList("Export-Package");
 	}

 	void setExportPackages(ParameterValue[] value) {
 		if (value == null || value.length == 0) {
 			attributes.remove("Export-Package");
 		} else {
 			putList("Export-Package", value);
 		}
 	}

 	String getPlatformFilter() {
 		return getSimple("Eclipse-PlatformFilter");
 	}

 	void setPlatformFilter(String value) {
 		putSimple("Eclipse-PlatformFilter", value);
 	}

 	String[] getClassPath() {
 		return safeValueList("Bundle-ClassPath");
 	}

 	void setClassPath(String[] values) {
 		putList("Bundle-ClassPath", values);
 	}

 	ParameterValue[] getNativeCode() {
 		return safeList("Bundle-NativeCode");
 	}

 	String[] getRequiredExecutionEnvironment() {
 		return safeValueList("Bundle-RequiredExecutionEnvironment");
 	}

 	void setRequiredExecutionEnvironment(String[] values) {
 		putList("Bundle-RequiredExecutionEnvironment", values);
 	}

 	void setAutomaticModuleName(String value) {
 		putSimple("Automatic-Module-Name", value);
 	}

 	String getAutomaticModuleName() {
 		return getSimple("Automatic-Module-Name");
 	}

 	String getBundleVersion() {
 		return getSimple("Bundle-Version");
 	}

 	void setBundleVersion(String value) {
 		putSimple("Bundle-Version", value);
 	}

 	String getBundleVendor() {
 		return getSimple("Bundle-Vendor");
 	}

 	void setBundleVendor(String value) {
 		putSimple("Bundle-Vendor", value);
 	}

 	String getActivationPolicy() {
 		return getSimple("Bundle-ActivationPolicy");
 	}

 	void setLazyActivationPolicy() {
 		putSimple("Bundle-ActivationPolicy", "lazy");
 	}

 	/**
 	 * Returns the fragment host, or {@code null} if no fragment host is
 	 * defined.
 	 */
 	ParameterValue getFragmentHost() {
 		return firstValue("Fragment-Host");
 	}

 	/**
 	 * Returns {@code true} if the 'unpack' flag must be set (used by features).
 	 */
 	boolean getNeedUnpack() {
 		ParameterValue value = firstValue("Eclipse-BundleShape");
 		if (value != null && value.getValue() != null && value.getValue().equals("dir")) {
 			return true;
 		}

 		return false;
 	}

 	String[] getBinaryInclude() {
 		return safeValueList("Binary-Include");
 	}

 	private static final String MANIFEST_VERSION = "Manifest-Version";

 	void write(File mfFile) throws IOException {
 		// calculate the order of the manifest entries
 		if (referenceFile != null) {
 			calculateOrder();
 		}

 		// always provide a manifest version
 		ManifestAttribute mfVer = attributes.get(MANIFEST_VERSION);
 		if (mfVer == null) {
 			mfVer = new ManifestAttribute(MANIFEST_VERSION, "1.0");
 			attributes.put(MANIFEST_VERSION, mfVer);
 		}
 		mfVer.order = Integer.MIN_VALUE;

 		// sort the manifest entries
 		List<ManifestAttribute> sorted = new ArrayList<>(attributes.values());
 		Collections.sort(sorted, new Comparator<ManifestAttribute>() {

 			@Override
 			public int compare(ManifestAttribute a1, ManifestAttribute a2) {
 				if (a1.order < a2.order) {
 					return -1;
 				}
 				if (a1.order > a2.order) {
 					return 1;
 				}
 				return a1.name.compareTo(a2.name);
 			}
 		});

 		// write the manifest
 		Writer ps = new FileWriter(mfFile);
 		try {
 			for (ManifestAttribute mf : sorted) {
 				writeAttribute(mf.name, mf.values, ps);
 			}
 		} finally {
 			ps.close();
 		}
 	}

 	private static void writeAttribute(String name, ParameterValue[] value, Writer ps) throws IOException {
 		ps.write(name);
 		ps.write(": ");
 		boolean firstLine = true;
 		for (ParameterValue pv : value) {
 			if (firstLine) {
 				firstLine = false;
 			} else {
 				ps.write(",\n ");
 			}
 			pv.write(ps);
 		}
 		ps.write('\n');
 	}

 	private void calculateOrder() {
 		List<String> lines = new ArrayList<>();
 		try {
 			LineNumberReader r = new LineNumberReader(new FileReader(referenceFile));
 			try {
 				String line;
 				while ((line = r.readLine()) != null) {
 					lines.add(line);
 				}
 			} finally {
 				r.close();
 			}
 		} catch (Exception e) {
 			Activator.log(IStatus.ERROR, "cannot read " + referenceFile, e);
 			return;
 		}

 		int index = 0;
 		for (String line : lines) {
 			for (ManifestAttribute mf : attributes.values()) {
 				if (line.startsWith(mf.name + ':')) {
 					mf.order = index;
 					break;
 				}
 			}
 			++index;
 		}
 	}

 	public boolean migrateUnpackInformation() {
 		if (getBoolean("Unpack")) {
 			putSimple("Eclipse-BundleShape", "dir");
 			attributes.remove("Unpack");
 			return true;
 		}
 		return false;
 	}

 	public ParameterValue getBuddyPolicy() {
 		return firstValue("Eclipse-BuddyPolicy");
 	}

 	public ParameterValue[] getBuddyRegistrations() {
 		return safeList("Eclipse-RegisterBuddy");
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2017 SSI Schaefer IT Solutions GmbH and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* SSI Schaefer IT Solutions GmbH
	*******************************************************************************/
	package org.eclipse.tea.library.build.model;

	import static org.eclipse.tea.library.build.model.BundleData.splitList;

	import java.io.File;
	import java.io.FileReader;
	import java.io.FileWriter;
	import java.io.IOException;
	import java.io.LineNumberReader;
	import java.io.Writer;
	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.Comparator;
	import java.util.List;
	import java.util.Map;
	import java.util.TreeMap;
	import java.util.jar.Attributes;
	import java.util.jar.Manifest;

	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.tea.library.build.internal.Activator;

	/**
	* Abstraction of the famous {@code MANIFEST.MF} file.
	* <p>
	* Supports manipulation of the manifest whilst keeping track of the order of
	* headers.
	*/
	final class ManifestHolder {

	private static final ParameterValue[] EMPTY_VALUES = {};

	private final Map<String, ManifestAttribute> attributes = new TreeMap<>();
	private final File referenceFile;

	private ManifestHolder(final Manifest manifest, final File referenceFile) {
	final Attributes attr = manifest.getMainAttributes();
	for (Object key : attr.keySet()) {
	final String name = key.toString();
	final String[] values = splitList(attr, name);
	attributes.put(name, new ManifestAttribute(name, values));
	}

	this.referenceFile = referenceFile;
	}

	static ManifestHolder fromManifest(Manifest manifest, File manifestFile) {
	if (manifest == null) {
	return null;
	}
	return new ManifestHolder(manifest, manifestFile);
	}

	/**
	* Returns the value list to which the specified key is mapped, or
	* {@code null} if this map contains no mapping for the key.
	*/
	private ParameterValue[] getValues(String key) {
	ManifestAttribute attr = attributes.get(key);
	if (attr == null) {
	return null;
	}
	return attr.values;
	}

	private ParameterValue[] safeList(String name) {
	ParameterValue[] result = getValues(name);
	if (result == null) {
	return EMPTY_VALUES;
	}
	return result;
	}

	ParameterValue[] getListAttribute(String name) {
	return safeList(name);
	}

	ParameterValue getSingleAttribute(String name) {
	return firstValue(name);
	}

	/**
	* Returns the first parameter value to which the specified key is mapped,
	* or {@code null} if this map contains no mapping for the key or there are
	* no values.
	*/
	private ParameterValue firstValue(String key) {
	ParameterValue[] result = getValues(key);
	if (result == null \|\| result.length < 1) {
	return null;
	}
	return result[0];
	}

	private String[] safeValueList(String name) {
	ParameterValue[] result = getValues(name);
	if (result == null) {
	return BundleData.EMPTY_STRINGS;
	}
	return ParameterValue.valuesFromList(result);
	}

	private String getSimple(String name) {
	ParameterValue pv = firstValue(name);
	if (pv == null) {
	return null;
	}
	return pv.getValue();
	}

	private boolean getBoolean(String name) {
	return Boolean.parseBoolean(getSimple(name));
	}

	private void putSimple(String name, String value) {
	attributes.put(name, new ManifestAttribute(name, value));
	}

	private void putList(String name, String[] values) {
	attributes.put(name, new ManifestAttribute(name, values));
	}

	private void putList(String name, ParameterValue[] values) {
	attributes.put(name, new ManifestAttribute(name, values));
	}

	ParameterValue getSymbolicName() {
	return firstValue("Bundle-SymbolicName");
	}

	String getDescription() {
	return getSimple("Bundle-Name");
	}

	String getActivator() {
	return getSimple("Bundle-Activator");
	}

	void setActivator(String activator) {
	if (activator == null) {
	attributes.remove("Bundle-Activator");
	} else {
	putSimple("Bundle-Activator", activator);
	}
	}

	void addDependency(String pluginName, boolean optional) {
	ManifestAttribute reqBundleAttr = attributes.get("Require-Bundle");
	ParameterValue[] dependencies = reqBundleAttr.values;
	ParameterValue[] newDependecies = new ParameterValue[dependencies.length + 1];
	System.arraycopy(dependencies, 0, newDependecies, 0, dependencies.length);

	String param = optional ? ";resolution:=optional" : "";
	newDependecies[newDependecies.length - 1] = new ParameterValue(pluginName + param);

	ManifestAttribute manifestAttr = new ManifestAttribute("Require-Bundle", newDependecies);
	attributes.put("Require-Bundle", manifestAttr);
	}

	ParameterValue[] getDependencies() {
	return safeList("Require-Bundle");
	}

	ParameterValue[] getMavenDependencies() {
	if (attributes.containsKey("WAMAS-Build-Maven")) {
	// DEPRECATED
	return safeList("WAMAS-Build-Maven");
	}
	return safeList("Build-Maven");
	}

	ParameterValue[] getImportPackages() {
	return safeList("Import-Package");
	}

	ParameterValue[] getExportPackages() {
	return safeList("Export-Package");
	}

	void setExportPackages(ParameterValue[] value) {
	if (value == null \|\| value.length == 0) {
	attributes.remove("Export-Package");
	} else {
	putList("Export-Package", value);
	}
	}

	String getPlatformFilter() {
	return getSimple("Eclipse-PlatformFilter");
	}

	void setPlatformFilter(String value) {
	putSimple("Eclipse-PlatformFilter", value);
	}

	String[] getClassPath() {
	return safeValueList("Bundle-ClassPath");
	}

	void setClassPath(String[] values) {
	putList("Bundle-ClassPath", values);
	}

	ParameterValue[] getNativeCode() {
	return safeList("Bundle-NativeCode");
	}

	String[] getRequiredExecutionEnvironment() {
	return safeValueList("Bundle-RequiredExecutionEnvironment");
	}

	void setRequiredExecutionEnvironment(String[] values) {
	putList("Bundle-RequiredExecutionEnvironment", values);
	}

	void setAutomaticModuleName(String value) {
	putSimple("Automatic-Module-Name", value);
	}

	String getAutomaticModuleName() {
	return getSimple("Automatic-Module-Name");
	}

	String getBundleVersion() {
	return getSimple("Bundle-Version");
	}

	void setBundleVersion(String value) {
	putSimple("Bundle-Version", value);
	}

	String getBundleVendor() {
	return getSimple("Bundle-Vendor");
	}

	void setBundleVendor(String value) {
	putSimple("Bundle-Vendor", value);
	}

	String getActivationPolicy() {
	return getSimple("Bundle-ActivationPolicy");
	}

	void setLazyActivationPolicy() {
	putSimple("Bundle-ActivationPolicy", "lazy");
	}

	/**
	* Returns the fragment host, or {@code null} if no fragment host is
	* defined.
	*/
	ParameterValue getFragmentHost() {
	return firstValue("Fragment-Host");
	}

	/**
	* Returns {@code true} if the 'unpack' flag must be set (used by features).
	*/
	boolean getNeedUnpack() {
	ParameterValue value = firstValue("Eclipse-BundleShape");
	if (value != null && value.getValue() != null && value.getValue().equals("dir")) {
	return true;
	}

	return false;
	}

	String[] getBinaryInclude() {
	return safeValueList("Binary-Include");
	}

	private static final String MANIFEST_VERSION = "Manifest-Version";

	void write(File mfFile) throws IOException {
	// calculate the order of the manifest entries
	if (referenceFile != null) {
	calculateOrder();
	}

	// always provide a manifest version
	ManifestAttribute mfVer = attributes.get(MANIFEST_VERSION);
	if (mfVer == null) {
	mfVer = new ManifestAttribute(MANIFEST_VERSION, "1.0");
	attributes.put(MANIFEST_VERSION, mfVer);
	}
	mfVer.order = Integer.MIN_VALUE;

	// sort the manifest entries
	List<ManifestAttribute> sorted = new ArrayList<>(attributes.values());
	Collections.sort(sorted, new Comparator<ManifestAttribute>() {

	@Override
	public int compare(ManifestAttribute a1, ManifestAttribute a2) {
	if (a1.order < a2.order) {
	return -1;
	}
	if (a1.order > a2.order) {
	return 1;
	}
	return a1.name.compareTo(a2.name);
	}
	});

	// write the manifest
	Writer ps = new FileWriter(mfFile);
	try {
	for (ManifestAttribute mf : sorted) {
	writeAttribute(mf.name, mf.values, ps);
	}
	} finally {
	ps.close();
	}
	}

	private static void writeAttribute(String name, ParameterValue[] value, Writer ps) throws IOException {
	ps.write(name);
	ps.write(": ");
	boolean firstLine = true;
	for (ParameterValue pv : value) {
	if (firstLine) {
	firstLine = false;
	} else {
	ps.write(",\n ");
	}
	pv.write(ps);
	}
	ps.write('\n');
	}

	private void calculateOrder() {
	List<String> lines = new ArrayList<>();
	try {
	LineNumberReader r = new LineNumberReader(new FileReader(referenceFile));
	try {
	String line;
	while ((line = r.readLine()) != null) {
	lines.add(line);
	}
	} finally {
	r.close();
	}
	} catch (Exception e) {
	Activator.log(IStatus.ERROR, "cannot read " + referenceFile, e);
	return;
	}

	int index = 0;
	for (String line : lines) {
	for (ManifestAttribute mf : attributes.values()) {
	if (line.startsWith(mf.name + ':')) {
	mf.order = index;
	break;
	}
	}
	++index;
	}
	}

	public boolean migrateUnpackInformation() {
	if (getBoolean("Unpack")) {
	putSimple("Eclipse-BundleShape", "dir");
	attributes.remove("Unpack");
	return true;
	}
	return false;
	}

	public ParameterValue getBuddyPolicy() {
	return firstValue("Eclipse-BuddyPolicy");
	}

	public ParameterValue[] getBuddyRegistrations() {
	return safeList("Eclipse-RegisterBuddy");
	}

	}