bundles/org.eclipse.e4.core.macros/src/org/eclipse/e4/core/macros/internal/ComposableMacro.java - e4/org.eclipse.e4.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2017 Fabio Zadrozny 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:
  *     Fabio Zadrozny - initial API and implementation - http://eclip.se/8519
  *******************************************************************************/
 package org.eclipse.e4.core.macros.internal;

 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.Base64;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import javax.xml.parsers.DocumentBuilder;
 import javax.xml.parsers.DocumentBuilderFactory;
 import javax.xml.parsers.ParserConfigurationException;
 import javax.xml.transform.OutputKeys;
 import javax.xml.transform.Transformer;
 import javax.xml.transform.TransformerException;
 import javax.xml.transform.TransformerFactory;
 import javax.xml.transform.TransformerFactoryConfigurationError;
 import javax.xml.transform.dom.DOMSource;
 import javax.xml.transform.stream.StreamResult;
 import org.eclipse.core.runtime.Assert;
 import org.eclipse.e4.core.macros.IMacroInstruction;
 import org.eclipse.e4.core.macros.IMacroInstructionFactory;
 import org.eclipse.e4.core.macros.IMacroPlaybackContext;
 import org.eclipse.e4.core.macros.MacroPlaybackException;
 import org.w3c.dom.DOMException;
 import org.w3c.dom.Document;
 import org.w3c.dom.Element;

 /**
  * A macro that is created from a sequence of instructions which are stored
  * in-memory (and may be persisted later on).
  */
 public class ComposableMacro implements IMacro {

 	public static final String XML_MACRO_TAG = "macro"; //$NON-NLS-1$

 	public static final String XML_INSTRUCTION_TAG = "instruction"; //$NON-NLS-1$

 	public static final String XML_ID_ATTRIBUTE = "id"; //$NON-NLS-1$

 	public static final String XML_BASE64_ATTRIBUTE = "base64"; //$NON-NLS-1$

 	public static final String XML_BASE64_ATTRIBUTE_TRUE = "true"; //$NON-NLS-1$

 	public static final String XML_DEFINITION_TAG = "definition"; //$NON-NLS-1$

 	public static final String XML_KEY_TAG = "key"; //$NON-NLS-1$

 	public static final String XML_VALUE_TAG = "value"; //$NON-NLS-1$

 	/**
 	 * Provides the macro instruction id to an implementation which is able to
 	 * recreate it.
 	 */
 	private final Map<String, IMacroInstructionFactory> fMacroInstructionIdToFactory;

 	/**
 	 * The macro instructions which compose this macro.
 	 */
 	private List<IMacroInstruction> fMacroInstructions = new ArrayList<>();

 	private static class IndexAndPriority {

 		private final int fIndex;
 		private final int fPriority;

 		private IndexAndPriority(int index, int priority) {
 			fIndex = index;
 			fPriority = priority;
 		}
 	}

 	/**
 	 * Map of an event to the current index of the macro instruction in
 	 * fMacroInstructions and the priority for the given macro instruction.
 	 */
 	private final Map<Object, IndexAndPriority> fEventToPlacement = new HashMap<>();

 	/**
 	 * @param macroInstructionIdToFactory
 	 *            Only macros instructions which have ids available as keys in the
 	 *            macroInstructionIdToFactory will be accepted.
 	 */
 	public ComposableMacro(Map<String, IMacroInstructionFactory> macroInstructionIdToFactory) {
 		fMacroInstructionIdToFactory = macroInstructionIdToFactory;
 	}

 	/**
 	 * Checks whether the added macro instruction is suitable to be added to this
 	 * macro.
 	 *
 	 * @param macroInstruction
 	 *            the macro instruction to be checked.
 	 */
 	private void checkMacroInstruction(IMacroInstruction macroInstruction) {
 		Assert.isTrue(
 				fMacroInstructionIdToFactory == null
 						|| fMacroInstructionIdToFactory.containsKey(macroInstruction.getId()),
 				String.format("Macro instruction: %s not properly registered through a %s extension point.", //$NON-NLS-1$
 						macroInstruction.getId(), MacroServiceImpl.MACRO_INSTRUCTION_FACTORY_EXTENSION_POINT));
 	}

 	/**
 	 * Adds a new macro instruction to this macro.
 	 *
 	 * @param macroInstruction
 	 *            the macro instruction to be appended to this macro.
 	 */
 	public void addMacroInstruction(IMacroInstruction macroInstruction) {
 		checkMacroInstruction(macroInstruction);
 		fMacroInstructions.add(macroInstruction);
 	}

 	/**
 	 * Adds a macro instruction to be added to the current macro being recorded.
 	 * This method should be used when an event may trigger the creation of multiple
 	 * macro instructions and only one of those should be recorded.
 	 *
 	 * @param macroInstruction
 	 *            the macro instruction to be added to the macro currently being
 	 *            recorded.
 	 * @param event
 	 *            the event that triggered the creation of the macro instruction to
 	 *            be added. If there are multiple macro instructions added for the
 	 *            same event, only the one with the highest priority will be kept
 	 *            (if 2 events have the same priority, the last one will replace the
 	 *            previous one).
 	 * @param priority
 	 *            the priority of the macro instruction being added (to be compared
 	 *            against the priority of other added macro instructions for the
 	 *            same event).
 	 * @return true if the macro instruction was actually added and false otherwise.
 	 */
 	public boolean addMacroInstruction(IMacroInstruction macroInstruction, Object event, int priority) {
 		Assert.isNotNull(event);
 		IndexAndPriority currentIndexAndPriority = fEventToPlacement.get(event);
 		if (currentIndexAndPriority == null) {
 			addMacroInstruction(macroInstruction);
 			fEventToPlacement.put(event, new IndexAndPriority(fMacroInstructions.size() - 1, priority));
 			return true;
 		}
 		if (priority >= currentIndexAndPriority.fPriority) {
 			checkMacroInstruction(macroInstruction);
 			fMacroInstructions.set(currentIndexAndPriority.fIndex, macroInstruction);
 			fEventToPlacement.put(event, new IndexAndPriority(currentIndexAndPriority.fIndex, priority));
 			return true;
 		}
 		return false;
 	}

 	/**
 	 * Clears information obtained during recording which should be no longer needed
 	 * after the macro is properly composed.
 	 */
 	public void clearCachedInfo() {
 		fEventToPlacement.clear();
 	}

 	@Override
 	public void playback(IMacroPlaybackContext macroPlaybackContext) throws MacroPlaybackException {
 		for (IMacroInstruction macroInstruction : fMacroInstructions) {
 			macroInstruction.execute(macroPlaybackContext);
 		}
 	}

 	/**
 	 * Actually returns the bytes to be written to the disk to be loaded back later
 	 * on (the actual load and playback is later done by {@link SavedXMLMacro}).
 	 *
 	 * @return an UTF-8 encoded array of bytes which can be used to rerun the macro
 	 *         later on.
 	 * @throws IOException
 	 *             if some error happens converting the macro to XML.
 	 */
 	public byte[] toXMLBytes() throws IOException {
 		try {
 			DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
 			factory.setFeature("http://xml.org/sax/features/namespaces", false); //$NON-NLS-1$
 			factory.setFeature("http://xml.org/sax/features/validation", false); //$NON-NLS-1$
 			factory.setFeature("http://apache.org/xml/features/nonvalidating/load-dtd-grammar", false); //$NON-NLS-1$
 			factory.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false); //$NON-NLS-1$

 			DocumentBuilder documentBuilder = factory.newDocumentBuilder();
 			Document document = documentBuilder.newDocument();
 			Element root = document.createElement(XML_MACRO_TAG);

 			for (IMacroInstruction macroInstruction : fMacroInstructions) {
 				Map<String, String> map = macroInstruction.toMap();
 				Iterator<Entry<String, String>> iterator = map.entrySet().iterator();

 				Element instructionElement = document.createElement(XML_INSTRUCTION_TAG);
 				instructionElement.setAttribute(XML_ID_ATTRIBUTE, macroInstruction.getId());
 				Element instructionDefinition = document.createElement(XML_DEFINITION_TAG);
 				while (iterator.hasNext()) {
 					Entry<String, String> entry = iterator.next();

 					instructionDefinition
 							.appendChild(setTextContent(document.createElement(XML_KEY_TAG), entry.getKey()));
 					instructionDefinition
 							.appendChild(setTextContent(document.createElement(XML_VALUE_TAG), entry.getValue()));
 				}
 				instructionElement.appendChild(instructionDefinition);
 				root.appendChild(instructionElement);
 			}
 			document.appendChild(root);

 			ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

 			Transformer transformer = TransformerFactory.newInstance().newTransformer();
 			transformer.setOutputProperty(OutputKeys.METHOD, "xml"); //$NON-NLS-1$
 			transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8"); //$NON-NLS-1$
 			transformer.setOutputProperty(OutputKeys.INDENT, "yes"); //$NON-NLS-1$
 			transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2"); //$NON-NLS-1$//$NON-NLS-2$

 			DOMSource source = new DOMSource(document);
 			StreamResult outputTarget = new StreamResult(outputStream);
 			transformer.transform(source, outputTarget);
 			return outputStream.toByteArray();
 		} catch (DOMException | IllegalArgumentException | ParserConfigurationException
 				| TransformerFactoryConfigurationError | TransformerException e) {
 			throw new IOException("Error converting macro to XML.", e); //$NON-NLS-1$
 		}
 	}

 	private Element setTextContent(Element element, String str) {
 		if (isAsciiPrintable(str)) {
 			element.setTextContent(str);
 		} else {
 			element.setTextContent(new String(Base64.getEncoder().encode(str.getBytes(StandardCharsets.UTF_8)),
 					StandardCharsets.UTF_8));
 			element.setAttribute(XML_BASE64_ATTRIBUTE, XML_BASE64_ATTRIBUTE_TRUE);
 		}
 		return element;
 	}

 	private static boolean isAsciiPrintable(String str) {
 		int length = str.length();
 		for (int i = 0; i < length; i++) {
 			char c = str.charAt(i);
 			if (!(c >= 32 && c < 127)) {
 				return false;
 			}
 		}
 		return true;
 	}

 	/**
 	 * Provides the number of macro instructions which have been added to this
 	 * macro.
 	 *
 	 * @return the number of macro instructions in this macro.
 	 */
 	public int getLength() {
 		return fMacroInstructions.size();
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2017 Fabio Zadrozny 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:
	* Fabio Zadrozny - initial API and implementation - http://eclip.se/8519
	*******************************************************************************/
	package org.eclipse.e4.core.macros.internal;

	import java.io.ByteArrayOutputStream;
	import java.io.IOException;
	import java.nio.charset.StandardCharsets;
	import java.util.ArrayList;
	import java.util.Base64;
	import java.util.HashMap;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;
	import java.util.Map.Entry;
	import javax.xml.parsers.DocumentBuilder;
	import javax.xml.parsers.DocumentBuilderFactory;
	import javax.xml.parsers.ParserConfigurationException;
	import javax.xml.transform.OutputKeys;
	import javax.xml.transform.Transformer;
	import javax.xml.transform.TransformerException;
	import javax.xml.transform.TransformerFactory;
	import javax.xml.transform.TransformerFactoryConfigurationError;
	import javax.xml.transform.dom.DOMSource;
	import javax.xml.transform.stream.StreamResult;
	import org.eclipse.core.runtime.Assert;
	import org.eclipse.e4.core.macros.IMacroInstruction;
	import org.eclipse.e4.core.macros.IMacroInstructionFactory;
	import org.eclipse.e4.core.macros.IMacroPlaybackContext;
	import org.eclipse.e4.core.macros.MacroPlaybackException;
	import org.w3c.dom.DOMException;
	import org.w3c.dom.Document;
	import org.w3c.dom.Element;

	/**
	* A macro that is created from a sequence of instructions which are stored
	* in-memory (and may be persisted later on).
	*/
	public class ComposableMacro implements IMacro {

	public static final String XML_MACRO_TAG = "macro"; //$NON-NLS-1$

	public static final String XML_INSTRUCTION_TAG = "instruction"; //$NON-NLS-1$

	public static final String XML_ID_ATTRIBUTE = "id"; //$NON-NLS-1$

	public static final String XML_BASE64_ATTRIBUTE = "base64"; //$NON-NLS-1$

	public static final String XML_BASE64_ATTRIBUTE_TRUE = "true"; //$NON-NLS-1$

	public static final String XML_DEFINITION_TAG = "definition"; //$NON-NLS-1$

	public static final String XML_KEY_TAG = "key"; //$NON-NLS-1$

	public static final String XML_VALUE_TAG = "value"; //$NON-NLS-1$

	/**
	* Provides the macro instruction id to an implementation which is able to
	* recreate it.
	*/
	private final Map<String, IMacroInstructionFactory> fMacroInstructionIdToFactory;

	/**
	* The macro instructions which compose this macro.
	*/
	private List<IMacroInstruction> fMacroInstructions = new ArrayList<>();

	private static class IndexAndPriority {

	private final int fIndex;
	private final int fPriority;

	private IndexAndPriority(int index, int priority) {
	fIndex = index;
	fPriority = priority;
	}
	}

	/**
	* Map of an event to the current index of the macro instruction in
	* fMacroInstructions and the priority for the given macro instruction.
	*/
	private final Map<Object, IndexAndPriority> fEventToPlacement = new HashMap<>();

	/**
	* @param macroInstructionIdToFactory
	* Only macros instructions which have ids available as keys in the
	* macroInstructionIdToFactory will be accepted.
	*/
	public ComposableMacro(Map<String, IMacroInstructionFactory> macroInstructionIdToFactory) {
	fMacroInstructionIdToFactory = macroInstructionIdToFactory;
	}

	/**
	* Checks whether the added macro instruction is suitable to be added to this
	* macro.
	*
	* @param macroInstruction
	* the macro instruction to be checked.
	*/
	private void checkMacroInstruction(IMacroInstruction macroInstruction) {
	Assert.isTrue(
	fMacroInstructionIdToFactory == null
	\|\| fMacroInstructionIdToFactory.containsKey(macroInstruction.getId()),
	String.format("Macro instruction: %s not properly registered through a %s extension point.", //$NON-NLS-1$
	macroInstruction.getId(), MacroServiceImpl.MACRO_INSTRUCTION_FACTORY_EXTENSION_POINT));
	}

	/**
	* Adds a new macro instruction to this macro.
	*
	* @param macroInstruction
	* the macro instruction to be appended to this macro.
	*/
	public void addMacroInstruction(IMacroInstruction macroInstruction) {
	checkMacroInstruction(macroInstruction);
	fMacroInstructions.add(macroInstruction);
	}

	/**
	* Adds a macro instruction to be added to the current macro being recorded.
	* This method should be used when an event may trigger the creation of multiple
	* macro instructions and only one of those should be recorded.
	*
	* @param macroInstruction
	* the macro instruction to be added to the macro currently being
	* recorded.
	* @param event
	* the event that triggered the creation of the macro instruction to
	* be added. If there are multiple macro instructions added for the
	* same event, only the one with the highest priority will be kept
	* (if 2 events have the same priority, the last one will replace the
	* previous one).
	* @param priority
	* the priority of the macro instruction being added (to be compared
	* against the priority of other added macro instructions for the
	* same event).
	* @return true if the macro instruction was actually added and false otherwise.
	*/
	public boolean addMacroInstruction(IMacroInstruction macroInstruction, Object event, int priority) {
	Assert.isNotNull(event);
	IndexAndPriority currentIndexAndPriority = fEventToPlacement.get(event);
	if (currentIndexAndPriority == null) {
	addMacroInstruction(macroInstruction);
	fEventToPlacement.put(event, new IndexAndPriority(fMacroInstructions.size() - 1, priority));
	return true;
	}
	if (priority >= currentIndexAndPriority.fPriority) {
	checkMacroInstruction(macroInstruction);
	fMacroInstructions.set(currentIndexAndPriority.fIndex, macroInstruction);
	fEventToPlacement.put(event, new IndexAndPriority(currentIndexAndPriority.fIndex, priority));
	return true;
	}
	return false;
	}

	/**
	* Clears information obtained during recording which should be no longer needed
	* after the macro is properly composed.
	*/
	public void clearCachedInfo() {
	fEventToPlacement.clear();
	}

	@Override
	public void playback(IMacroPlaybackContext macroPlaybackContext) throws MacroPlaybackException {
	for (IMacroInstruction macroInstruction : fMacroInstructions) {
	macroInstruction.execute(macroPlaybackContext);
	}
	}

	/**
	* Actually returns the bytes to be written to the disk to be loaded back later
	* on (the actual load and playback is later done by {@link SavedXMLMacro}).
	*
	* @return an UTF-8 encoded array of bytes which can be used to rerun the macro
	* later on.
	* @throws IOException
	* if some error happens converting the macro to XML.
	*/
	public byte[] toXMLBytes() throws IOException {
	try {
	DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
	factory.setFeature("http://xml.org/sax/features/namespaces", false); //$NON-NLS-1$
	factory.setFeature("http://xml.org/sax/features/validation", false); //$NON-NLS-1$
	factory.setFeature("http://apache.org/xml/features/nonvalidating/load-dtd-grammar", false); //$NON-NLS-1$
	factory.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false); //$NON-NLS-1$

	DocumentBuilder documentBuilder = factory.newDocumentBuilder();
	Document document = documentBuilder.newDocument();
	Element root = document.createElement(XML_MACRO_TAG);

	for (IMacroInstruction macroInstruction : fMacroInstructions) {
	Map<String, String> map = macroInstruction.toMap();
	Iterator<Entry<String, String>> iterator = map.entrySet().iterator();

	Element instructionElement = document.createElement(XML_INSTRUCTION_TAG);
	instructionElement.setAttribute(XML_ID_ATTRIBUTE, macroInstruction.getId());
	Element instructionDefinition = document.createElement(XML_DEFINITION_TAG);
	while (iterator.hasNext()) {
	Entry<String, String> entry = iterator.next();

	instructionDefinition
	.appendChild(setTextContent(document.createElement(XML_KEY_TAG), entry.getKey()));
	instructionDefinition
	.appendChild(setTextContent(document.createElement(XML_VALUE_TAG), entry.getValue()));
	}
	instructionElement.appendChild(instructionDefinition);
	root.appendChild(instructionElement);
	}
	document.appendChild(root);

	ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

	Transformer transformer = TransformerFactory.newInstance().newTransformer();
	transformer.setOutputProperty(OutputKeys.METHOD, "xml"); //$NON-NLS-1$
	transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8"); //$NON-NLS-1$
	transformer.setOutputProperty(OutputKeys.INDENT, "yes"); //$NON-NLS-1$
	transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2"); //$NON-NLS-1$//$NON-NLS-2$

	DOMSource source = new DOMSource(document);
	StreamResult outputTarget = new StreamResult(outputStream);
	transformer.transform(source, outputTarget);
	return outputStream.toByteArray();
	} catch (DOMException \| IllegalArgumentException \| ParserConfigurationException
	\| TransformerFactoryConfigurationError \| TransformerException e) {
	throw new IOException("Error converting macro to XML.", e); //$NON-NLS-1$
	}
	}

	private Element setTextContent(Element element, String str) {
	if (isAsciiPrintable(str)) {
	element.setTextContent(str);
	} else {
	element.setTextContent(new String(Base64.getEncoder().encode(str.getBytes(StandardCharsets.UTF_8)),
	StandardCharsets.UTF_8));
	element.setAttribute(XML_BASE64_ATTRIBUTE, XML_BASE64_ATTRIBUTE_TRUE);
	}
	return element;
	}

	private static boolean isAsciiPrintable(String str) {
	int length = str.length();
	for (int i = 0; i < length; i++) {
	char c = str.charAt(i);
	if (!(c >= 32 && c < 127)) {
	return false;
	}
	}
	return true;
	}

	/**
	* Provides the number of macro instructions which have been added to this
	* macro.
	*
	* @return the number of macro instructions in this macro.
	*/
	public int getLength() {
	return fMacroInstructions.size();
	}
	}