bundles/org.eclipse.wst.xsl.jaxp.launching/src/org/eclipse/wst/xsl/jaxp/launching/internal/LaunchHelper.java

/*******************************************************************************
 * Copyright (c) 2007 Chase Technology Ltd - http://www.chasetechnology.co.uk
 * 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:
 *     Doug Satchwell (Chase Technology Ltd) - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.xsl.jaxp.launching.internal;

import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.net.URL;
import java.util.Iterator;
import java.util.Map;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.TransformerException;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.wst.xsl.jaxp.debug.invoker.PipelineDefinition;
import org.eclipse.wst.xsl.jaxp.debug.invoker.TransformDefinition;
import org.eclipse.wst.xsl.jaxp.debug.invoker.TypedValue;
import org.eclipse.wst.xsl.jaxp.launching.IAttribute;
import org.eclipse.wst.xsl.jaxp.launching.IProcessorInstall;
import org.eclipse.wst.xsl.jaxp.launching.IProcessorType;
import org.eclipse.wst.xsl.jaxp.launching.ITransformerFactory;
import org.eclipse.wst.xsl.jaxp.launching.JAXPLaunchConfigurationConstants;
import org.eclipse.wst.xsl.jaxp.launching.JAXPRuntime;
import org.eclipse.wst.xsl.jaxp.launching.LaunchAttributes;
import org.eclipse.wst.xsl.jaxp.launching.LaunchProperties;
import org.eclipse.wst.xsl.launching.config.BaseLaunchHelper;
import org.eclipse.wst.xsl.launching.config.LaunchAttribute;
import org.eclipse.wst.xsl.launching.config.LaunchTransform;
import org.eclipse.wst.xsl.launching.config.PreferenceUtil;
import org.w3c.dom.Document;

public class LaunchHelper extends BaseLaunchHelper {
	private final LaunchAttributes attributes;
	private final LaunchProperties outputProperties;
	private final ITransformerFactory transformerFactory;

	public LaunchHelper(ILaunchConfiguration configuration)
			throws CoreException {
		super(configuration);
		attributes = hydrateAttributes(configuration);
		outputProperties = hydrateOutputProperties(configuration);
		transformerFactory = hydrateTransformerFactory(configuration);
	}

	public LaunchProperties getProperties() {
		return outputProperties;
	}

	public LaunchAttributes getAttributes() {
		return attributes;
	}

	public void save(File file) throws CoreException {
		BufferedWriter writer = null;
		try {
			// ensure it exists
			file.createNewFile();
			writer = new BufferedWriter(new FileWriter(file));
			PipelineDefinition pdef = new PipelineDefinition();
			for (Iterator<?> iter = attributes.getAttributes().iterator(); iter
					.hasNext();) {
				LaunchAttribute att = (LaunchAttribute) iter.next();
				pdef.addAttribute(new TypedValue(att.uri,
						TypedValue.TYPE_STRING, att.value));
			}
			for (Iterator<?> iter = pipeline.getTransformDefs().iterator(); iter
					.hasNext();) {
				LaunchTransform lt = (LaunchTransform) iter.next();
				TransformDefinition tdef = new TransformDefinition();
				URL url = pathToURL(lt.getLocation());
				tdef.setStylesheetURL(url.toExternalForm());
				tdef.setResolverClass(lt.getResolver());
				for (Iterator<?> iterator = lt.getParameters().iterator(); iterator
						.hasNext();) {
					LaunchAttribute att = (LaunchAttribute) iterator.next();
					tdef.addParameter(new TypedValue(att.uri,
							TypedValue.TYPE_STRING, att.getResolvedValue()));
				}
				// set the output props for the LAST transform only
				if (!iter.hasNext()) {
					for (Map.Entry<String, String> entry : outputProperties
							.getProperties().entrySet()) {
						String name = entry.getKey();
						String value = entry.getValue();
						if (name != null && value != null)
							tdef.setOutputProperty(name, value);
					}
				}
				pdef.addTransformDef(tdef);
			}

			Document doc = pdef.toXML();
			String s = PreferenceUtil.serializeDocument(doc);
			writer.write(s);
		} catch (FileNotFoundException e) {
			throw new CoreException(new Status(IStatus.ERROR,
					JAXPLaunchingPlugin.PLUGIN_ID, IStatus.ERROR,
					Messages.LaunchHelper_0, e));
		} catch (IOException e) {
			throw new CoreException(new Status(IStatus.ERROR,
					JAXPLaunchingPlugin.PLUGIN_ID, IStatus.ERROR,
					Messages.LaunchHelper_1, e));
		} catch (ParserConfigurationException e) {
			throw new CoreException(new Status(IStatus.ERROR,
					JAXPLaunchingPlugin.PLUGIN_ID, IStatus.ERROR,
					"ParserConfigurationException", e)); //$NON-NLS-1$
		} catch (TransformerException e) {
			throw new CoreException(new Status(IStatus.ERROR,
					JAXPLaunchingPlugin.PLUGIN_ID, IStatus.ERROR,
					"TransformerException", e)); //$NON-NLS-1$
		} finally {
			if (writer != null) {
				try {
					writer.close();
				} catch (IOException e) {
					JAXPLaunchingPlugin.log(e);
				}
			}
		}
	}

	public static LaunchProperties hydrateOutputProperties(
			ILaunchConfiguration configuration) throws CoreException {
		LaunchProperties properties = new LaunchProperties();
		boolean usePreferenceProperties = false; // configuration.getAttribute(JAXPLaunchConfigurationConstants.ATTR_USE_PROPERTIES_FROM_PREFERENCES,
													// true);
		IProcessorType pt = getProcessorInstall(configuration)
				.getProcessorType();
		if (usePreferenceProperties) {
			for (Map.Entry<String, String> entry : pt.getOutputPropertyValues()
					.entrySet()) {
				String name = entry.getKey();
				String value = entry.getValue();
				properties.setProperty(name, value);
			}
		} else {
			String s = configuration.getAttribute(
					JAXPLaunchConfigurationConstants.ATTR_OUTPUT_PROPERTIES,
					(String) null);
			if (s != null && s.length() > 0) {
				ByteArrayInputStream inputStream = new ByteArrayInputStream(s
						.getBytes());
				properties = LaunchProperties.fromXML(inputStream);
			}
		}
		return properties;
	}

	private static LaunchAttributes hydrateAttributes(
			ILaunchConfiguration configuration) throws CoreException {
		LaunchAttributes attributes = new LaunchAttributes();
		boolean useDefaultAttributes = false; // configuration.getAttribute(JAXPLaunchConfigurationConstants.ATTR_USE_FEATURES_FROM_PREFERENCES,
												// true);
		if (useDefaultAttributes) {
			IProcessorType pt = getProcessorInstall(configuration)
					.getProcessorType();
			Map<String, String> fvals = pt.getAttributeValues();
			for (Map.Entry<String, String> entry : fvals.entrySet()) {
				String uri = entry.getKey();
				getAttribute(pt.getAttributes(), uri);
				attributes.addAttribute(new LaunchAttribute(uri,
						"string", entry.getValue())); //$NON-NLS-1$
			}
		} else {
			String s = configuration.getAttribute(
					JAXPLaunchConfigurationConstants.ATTR_ATTRIBUTES,
					(String) null);
			if (s != null && s.length() > 0) {
				ByteArrayInputStream inputStream = new ByteArrayInputStream(s
						.getBytes());
				attributes = LaunchAttributes.fromXML(inputStream);
			}
		}
		return attributes;
	}

	private static IAttribute getAttribute(IAttribute[] attributes, String uri) {
		for (IAttribute attribute : attributes) {
			if (attribute.getURI().equals(uri))
				return attribute;
		}
		return null;
	}

	public static IProcessorInstall getProcessorInstall(
			ILaunchConfiguration configuration) throws CoreException {
		boolean useDefaultProcessor = configuration.getAttribute(
				JAXPLaunchConfigurationConstants.ATTR_USE_DEFAULT_PROCESSOR,
				true);
		if (useDefaultProcessor)
			return JAXPRuntime.getDefaultProcessor();
		String processorId = configuration.getAttribute(
				JAXPLaunchConfigurationConstants.ATTR_PROCESSOR, ""); //$NON-NLS-1$
		IProcessorInstall processor = JAXPRuntime.getProcessor(processorId);
		return processor;
	}

	private static ITransformerFactory hydrateTransformerFactory(
			ILaunchConfiguration configuration) throws CoreException {
		IProcessorType type = getProcessorInstall(configuration)
				.getProcessorType();
		boolean useDefaultFactory = configuration.getAttribute(
				JAXPLaunchConfigurationConstants.ATTR_USE_DEFAULT_PROCESSOR,
				true);
		if (useDefaultFactory)
			return type.getDefaultTransformerFactory();

		String factoryId = configuration.getAttribute(
				JAXPLaunchConfigurationConstants.ATTR_TRANSFORMER_FACTORY,
				(String) null);
		if (factoryId == null)
			return null;

		for (ITransformerFactory factory : type.getTransformerFactories()) {
			if (factory.getFactoryClass().equals(factoryId))
				return factory;
		}
		return null;
	}

	public ITransformerFactory getTransformerFactory() {
		return transformerFactory;
	}
}