plugins/org.eclipse.ease/src/org/eclipse/ease/AbstractCodeFactory.java - ease/org.eclipse.ease.core - Git at Google

 /*******************************************************************************
  * Copyright (c) 2013, 2016 Atos and others.
  * All rights reserved. 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-2.0/
  *
  * SPDX-License_Identifier: EPL-2.0
  *
  * Contributors:
  *     Arthur Daussy - initial implementation
  *******************************************************************************/
 package org.eclipse.ease;

 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;

 import org.eclipse.core.runtime.Platform;
 import org.eclipse.ease.modules.IEnvironment;
 import org.eclipse.ease.modules.ModuleHelper;
 import org.eclipse.ease.modules.ScriptParameter;
 import org.eclipse.ease.modules.WrapToScript;

 public abstract class AbstractCodeFactory implements ICodeFactory {

 	/** Default line break character. */
 	public static final String LINE_DELIMITER = System.getProperty(Platform.PREF_LINE_SEPARATOR);

 	protected String buildParameterList(List<Parameter> parameters) {
 		return parameters.stream().map(p -> toSafeName(p.getName())).collect(Collectors.joining(", "));
 	}

 	@Override
 	public String getDefaultValue(final Parameter parameter) {
 		final String defaultStringValue = parameter.getDefaultValue().replaceAll("\\r", "\\\\r").replaceAll("\\n", "\\\\n");

 		// null as default value
 		if (ScriptParameter.NULL.equals(defaultStringValue))
 			return getNullString();

 		// base datatypes
 		final Class<?> clazz = parameter.getClazz();
 		if ((Integer.class.equals(clazz)) || (int.class.equals(clazz))) {
 			try {
 				return Integer.toString(Integer.parseInt(defaultStringValue));
 			} catch (final NumberFormatException e1) {
 				throw new IllegalArgumentException(String.format("Cannot convert default value '%s' of parameter '%s' to %s", parameter.getDefaultValue(),
 						parameter.getName(), parameter.getClazz().getSimpleName()), e1);
 			}
 		}
 		if ((Long.class.equals(clazz)) || (long.class.equals(clazz))) {
 			try {
 				return Long.toString(Long.parseLong(defaultStringValue));
 			} catch (final NumberFormatException e1) {
 				throw new IllegalArgumentException(String.format("Cannot convert default value '%s' of parameter '%s' to %s", parameter.getDefaultValue(),
 						parameter.getName(), parameter.getClazz().getSimpleName()), e1);
 			}
 		}
 		if ((Byte.class.equals(clazz)) || (byte.class.equals(clazz))) {
 			try {
 				return Integer.toString(Integer.parseInt(defaultStringValue));
 			} catch (final NumberFormatException e1) {
 				throw new IllegalArgumentException(String.format("Cannot convert default value '%s' of parameter '%s' to %s", parameter.getDefaultValue(),
 						parameter.getName(), parameter.getClazz().getSimpleName()), e1);
 			}
 		}
 		if ((Float.class.equals(clazz)) || (float.class.equals(clazz))) {
 			try {
 				return Float.toString(Float.parseFloat(defaultStringValue));
 			} catch (final NumberFormatException e1) {
 				throw new IllegalArgumentException(String.format("Cannot convert default value '%s' of parameter '%s' to %s", parameter.getDefaultValue(),
 						parameter.getName(), parameter.getClazz().getSimpleName()), e1);
 			}
 		}
 		if ((Double.class.equals(clazz)) || (double.class.equals(clazz))) {
 			try {
 				return Double.toString(Double.parseDouble(defaultStringValue));
 			} catch (final NumberFormatException e1) {
 				throw new IllegalArgumentException(String.format("Cannot convert default value '%s' of parameter '%s' to %s", parameter.getDefaultValue(),
 						parameter.getName(), parameter.getClazz().getSimpleName()), e1);
 			}
 		}
 		if ((Boolean.class.equals(clazz)) || (boolean.class.equals(clazz))) {
 			return Boolean.parseBoolean(defaultStringValue) ? getTrueString() : getFalseString();
 		}
 		if ((Character.class.equals(clazz)) || (char.class.equals(clazz))) {
 			if (defaultStringValue.isEmpty())
 				throw new IllegalArgumentException(
 						String.format("Cannot convert empty default value of parameter '%s' to %s", parameter.getName(), parameter.getClazz().getSimpleName()));

 			return "'" + defaultStringValue.charAt(0) + "'";
 		}
 		if (String.class.equals(clazz))
 			return "\"" + defaultStringValue + "\"";

 		// undefined resolves to empty constructor
 		if (ScriptParameter.UNDEFINED.equals(defaultStringValue)) {
 			// look for empty constructor
 			try {
 				clazz.getConstructor();
 				// empty constructor found, return class
 				return classInstantiation(clazz, null);
 			} catch (final SecurityException e) {
 			} catch (final NoSuchMethodException e) {
 			}
 		}

 		// look for string constructor
 		try {
 			clazz.getConstructor(String.class);
 			// string constructor found, return class
 			return classInstantiation(clazz, new String[] { "\"" + defaultStringValue + "\"" });
 		} catch (final SecurityException e) {
 		} catch (final NoSuchMethodException e) {
 		}

 		// special handling for string defaults passed to an Object.class
 		if (clazz.isAssignableFrom(String.class))
 			return classInstantiation(String.class, new String[] { "\"" + defaultStringValue + "\"" });

 		return getNullString();
 	}

 	public static Collection<String> getMethodNames(final Method method) {
 		final Set<String> methodNames = new HashSet<>();
 		methodNames.add(method.getName());
 		methodNames.addAll(getMethodAliases(method));

 		return methodNames;
 	}

 	public static Collection<String> getMethodAliases(final Method method) {
 		final Set<String> methodAliases = new HashSet<>();

 		final WrapToScript wrapAnnotation = method.getAnnotation(WrapToScript.class);
 		if (wrapAnnotation != null) {
 			for (final String name : wrapAnnotation.alias().split(WrapToScript.DELIMITER))
 				if (!name.isBlank())
 					methodAliases.add(name.trim());
 		}

 		return methodAliases;
 	}

 	/**
 	 * Get string representation for <code>null</code> in target language.
 	 *
 	 * @return <code>null</code> in target language.
 	 */
 	protected abstract String getNullString();

 	/**
 	 * Get string representation for <code>true</code> in target language.
 	 *
 	 * @return <code>true</code> in target language.
 	 */
 	protected String getTrueString() {
 		return Boolean.TRUE.toString();
 	}

 	/**
 	 * Get string representation for <code>false</code> in target language.
 	 *
 	 * @return <code>false</code> in target language.
 	 */
 	protected String getFalseString() {
 		return Boolean.FALSE.toString();
 	}

 	@Override
 	public String createFunctionCall(final Method method, final Object... parameters) {
 		final String parameterString = Arrays.asList(parameters).stream().map(p -> parameterToString(p)).collect(Collectors.joining(", "));
 		return String.format("%s(%s);", method.getName(), parameterString);
 	}

 	private String parameterToString(Object parameter) {
 		if (parameter instanceof String)
 			return String.format("\"%s\"", ((String) parameter).replace("\"", "\\\"").replace("\\", "\\\\"));

 		if (parameter == null)
 			return getNullString();

 		if (parameter instanceof Boolean)
 			return ((Boolean) parameter) ? getTrueString() : getFalseString();

 		return parameter.toString();
 	}

 	/**
 	 * As many languages use //, provide a default of // style comments.
 	 *
 	 * @return "// "
 	 */
 	protected String getSingleLineCommentToken() {
 		return "// ";
 	}

 	/**
 	 * As many languages use /*, provide a default of /* style comments.
 	 *
 	 * @return "/*"
 	 */
 	protected String getMultiLineCommentStartToken() {
 		return "/*";
 	}

 	/**
 	 * Default block comment end token.
 	 *
 	 * @return asterisk, dash
 	 */
 	protected String getMultiLineCommentEndToken() {
 		return "*/";
 	}

 	@Override
 	public String createCommentedString(String comment, boolean addBlockComment) {
 		if (addBlockComment) {
 			return getMultiLineCommentStartToken() + comment + getMultiLineCommentEndToken();

 		} else {
 			final String token = getSingleLineCommentToken();
 			final Stream<String> split = Pattern.compile("\r?\n").splitAsStream(comment);
 			return split.map(s -> token + s).collect(Collectors.joining(System.lineSeparator()));
 		}
 	}

 	@Override
 	public String createWrapper(IEnvironment environment, Object instance, String identifier, boolean customNamespace, IScriptEngine engine) {

 		if (!customNamespace) {
 			// put functions/fields to global namespace
 			final StringBuilder scriptCode = new StringBuilder();

 			// create wrappers for methods
 			for (final Method method : ModuleHelper.getMethods(instance.getClass())) {
 				if (isSupportedByLanguage(method)) {

 					final String code = createFunctionWrapper(environment, identifier, method);

 					if ((code != null) && !code.isEmpty()) {
 						scriptCode.append(code);
 						scriptCode.append('\n');
 					}
 				}
 			}

 			// create wrappers for final fields
 			for (final Field field : ModuleHelper.getFields(instance.getClass())) {
 				if (isSupportedByLanguage(field)) {
 					final String code = createFieldWrapper(environment, identifier, field);

 					if ((code != null) && !code.isEmpty()) {
 						scriptCode.append(code);
 						scriptCode.append('\n');
 					}
 				}
 			}

 			return scriptCode.toString();

 		} else
 			throw new RuntimeException("Object wrappers not supported by default wrapper");
 	}

 	/**
 	 * Verify that a method can be wrapped for the current target language.
 	 *
 	 * @param method
 	 *            method to be queried
 	 * @return <code>true</code> when method can be wrapped
 	 */
 	protected boolean isSupportedByLanguage(Method method) {
 		return isSupportedByLanguage(method.getAnnotation(WrapToScript.class));
 	}

 	/**
 	 * Verify that a field can be wrapped for the current target language.
 	 *
 	 * @param field
 	 *            method to be queried
 	 * @return <code>true</code> when field can be wrapped
 	 */
 	protected boolean isSupportedByLanguage(Field field) {
 		return isSupportedByLanguage(field.getAnnotation(WrapToScript.class));
 	}

 	/**
 	 * Verify that an annotation indicates wrapping support for the current target language.
 	 *
 	 * @param annotation
 	 *            annotation to be queried
 	 * @return <code>true</code> when annotation indicated wrapping support
 	 */
 	private boolean isSupportedByLanguage(WrapToScript annotation) {
 		if (annotation != null) {
 			final String languages = annotation.supportedLanguages().trim();
 			if (!languages.isEmpty()) {
 				final String[] supportedLanguages = languages.split(",");
 				if (supportedLanguages[0].startsWith("!")) {
 					// exclude pattern
 					for (final String language : supportedLanguages) {
 						if (language.substring(1).equals(getLanguageIdentifier()))
 							return false;
 					}

 				} else {
 					// include pattern
 					for (final String language : supportedLanguages) {
 						if (language.equals(getLanguageIdentifier()))
 							return true;
 					}

 					return false;
 				}
 			}
 		}

 		return true;
 	}

 	/**
 	 * Get the language identifier for this code factory.
 	 *
 	 * @return language identifier as defined in extension point scriptType.name
 	 */
 	protected abstract Object getLanguageIdentifier();

 	/**
 	 * Create code for a method wrapper function in the global namespace of the script engine.
 	 *
 	 * @param environment
 	 *            environment instance
 	 * @param identifier
 	 *            function name to be used
 	 * @param method
 	 *            method to refer to
 	 * @return script code to be injected into the script engine
 	 */
 	protected abstract String createFunctionWrapper(IEnvironment environment, String identifier, Method method);

 	/**
 	 * Create code for a field wrapper function in the global namespace of the script engine.
 	 *
 	 * @param environment
 	 *            environment instance
 	 * @param identifier
 	 *            function name to be used
 	 * @param field
 	 *            field to refer to
 	 * @return script code to be injected into the script engine
 	 */
 	protected abstract String createFieldWrapper(IEnvironment environment, String identifier, Field field);

 	/**
 	 * Convert a given name to a script language safe name. To make sure it is safe we check against a list of given keywords. We then append '_' until the
 	 * value is save.
 	 *
 	 * @param name
 	 *            name to check
 	 * @return safe name
 	 */
 	protected abstract String toSafeName(String name);
 }
	/*******************************************************************************
	* Copyright (c) 2013, 2016 Atos and others.
	* All rights reserved. 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-2.0/
	*
	* SPDX-License_Identifier: EPL-2.0
	*
	* Contributors:
	* Arthur Daussy - initial implementation
	*******************************************************************************/
	package org.eclipse.ease;

	import java.lang.reflect.Field;
	import java.lang.reflect.Method;
	import java.util.Arrays;
	import java.util.Collection;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Set;
	import java.util.regex.Pattern;
	import java.util.stream.Collectors;
	import java.util.stream.Stream;

	import org.eclipse.core.runtime.Platform;
	import org.eclipse.ease.modules.IEnvironment;
	import org.eclipse.ease.modules.ModuleHelper;
	import org.eclipse.ease.modules.ScriptParameter;
	import org.eclipse.ease.modules.WrapToScript;

	public abstract class AbstractCodeFactory implements ICodeFactory {

	/** Default line break character. */
	public static final String LINE_DELIMITER = System.getProperty(Platform.PREF_LINE_SEPARATOR);

	protected String buildParameterList(List<Parameter> parameters) {
	return parameters.stream().map(p -> toSafeName(p.getName())).collect(Collectors.joining(", "));
	}

	@Override
	public String getDefaultValue(final Parameter parameter) {
	final String defaultStringValue = parameter.getDefaultValue().replaceAll("\\r", "\\\\r").replaceAll("\\n", "\\\\n");

	// null as default value
	if (ScriptParameter.NULL.equals(defaultStringValue))
	return getNullString();

	// base datatypes
	final Class<?> clazz = parameter.getClazz();
	if ((Integer.class.equals(clazz)) \|\| (int.class.equals(clazz))) {
	try {
	return Integer.toString(Integer.parseInt(defaultStringValue));
	} catch (final NumberFormatException e1) {
	throw new IllegalArgumentException(String.format("Cannot convert default value '%s' of parameter '%s' to %s", parameter.getDefaultValue(),
	parameter.getName(), parameter.getClazz().getSimpleName()), e1);
	}
	}
	if ((Long.class.equals(clazz)) \|\| (long.class.equals(clazz))) {
	try {
	return Long.toString(Long.parseLong(defaultStringValue));
	} catch (final NumberFormatException e1) {
	throw new IllegalArgumentException(String.format("Cannot convert default value '%s' of parameter '%s' to %s", parameter.getDefaultValue(),
	parameter.getName(), parameter.getClazz().getSimpleName()), e1);
	}
	}
	if ((Byte.class.equals(clazz)) \|\| (byte.class.equals(clazz))) {
	try {
	return Integer.toString(Integer.parseInt(defaultStringValue));
	} catch (final NumberFormatException e1) {
	throw new IllegalArgumentException(String.format("Cannot convert default value '%s' of parameter '%s' to %s", parameter.getDefaultValue(),
	parameter.getName(), parameter.getClazz().getSimpleName()), e1);
	}
	}
	if ((Float.class.equals(clazz)) \|\| (float.class.equals(clazz))) {
	try {
	return Float.toString(Float.parseFloat(defaultStringValue));
	} catch (final NumberFormatException e1) {
	throw new IllegalArgumentException(String.format("Cannot convert default value '%s' of parameter '%s' to %s", parameter.getDefaultValue(),
	parameter.getName(), parameter.getClazz().getSimpleName()), e1);
	}
	}
	if ((Double.class.equals(clazz)) \|\| (double.class.equals(clazz))) {
	try {
	return Double.toString(Double.parseDouble(defaultStringValue));
	} catch (final NumberFormatException e1) {
	throw new IllegalArgumentException(String.format("Cannot convert default value '%s' of parameter '%s' to %s", parameter.getDefaultValue(),
	parameter.getName(), parameter.getClazz().getSimpleName()), e1);
	}
	}
	if ((Boolean.class.equals(clazz)) \|\| (boolean.class.equals(clazz))) {
	return Boolean.parseBoolean(defaultStringValue) ? getTrueString() : getFalseString();
	}
	if ((Character.class.equals(clazz)) \|\| (char.class.equals(clazz))) {
	if (defaultStringValue.isEmpty())
	throw new IllegalArgumentException(
	String.format("Cannot convert empty default value of parameter '%s' to %s", parameter.getName(), parameter.getClazz().getSimpleName()));

	return "'" + defaultStringValue.charAt(0) + "'";
	}
	if (String.class.equals(clazz))
	return "\"" + defaultStringValue + "\"";

	// undefined resolves to empty constructor
	if (ScriptParameter.UNDEFINED.equals(defaultStringValue)) {
	// look for empty constructor
	try {
	clazz.getConstructor();
	// empty constructor found, return class
	return classInstantiation(clazz, null);
	} catch (final SecurityException e) {
	} catch (final NoSuchMethodException e) {
	}
	}

	// look for string constructor
	try {
	clazz.getConstructor(String.class);
	// string constructor found, return class
	return classInstantiation(clazz, new String[] { "\"" + defaultStringValue + "\"" });
	} catch (final SecurityException e) {
	} catch (final NoSuchMethodException e) {
	}

	// special handling for string defaults passed to an Object.class
	if (clazz.isAssignableFrom(String.class))
	return classInstantiation(String.class, new String[] { "\"" + defaultStringValue + "\"" });

	return getNullString();
	}

	public static Collection<String> getMethodNames(final Method method) {
	final Set<String> methodNames = new HashSet<>();
	methodNames.add(method.getName());
	methodNames.addAll(getMethodAliases(method));

	return methodNames;
	}

	public static Collection<String> getMethodAliases(final Method method) {
	final Set<String> methodAliases = new HashSet<>();

	final WrapToScript wrapAnnotation = method.getAnnotation(WrapToScript.class);
	if (wrapAnnotation != null) {
	for (final String name : wrapAnnotation.alias().split(WrapToScript.DELIMITER))
	if (!name.isBlank())
	methodAliases.add(name.trim());
	}

	return methodAliases;
	}

	/**
	* Get string representation for <code>null</code> in target language.
	*
	* @return <code>null</code> in target language.
	*/
	protected abstract String getNullString();

	/**
	* Get string representation for <code>true</code> in target language.
	*
	* @return <code>true</code> in target language.
	*/
	protected String getTrueString() {
	return Boolean.TRUE.toString();
	}

	/**
	* Get string representation for <code>false</code> in target language.
	*
	* @return <code>false</code> in target language.
	*/
	protected String getFalseString() {
	return Boolean.FALSE.toString();
	}

	@Override
	public String createFunctionCall(final Method method, final Object... parameters) {
	final String parameterString = Arrays.asList(parameters).stream().map(p -> parameterToString(p)).collect(Collectors.joining(", "));
	return String.format("%s(%s);", method.getName(), parameterString);
	}

	private String parameterToString(Object parameter) {
	if (parameter instanceof String)
	return String.format("\"%s\"", ((String) parameter).replace("\"", "\\\"").replace("\\", "\\\\"));

	if (parameter == null)
	return getNullString();

	if (parameter instanceof Boolean)
	return ((Boolean) parameter) ? getTrueString() : getFalseString();

	return parameter.toString();
	}

	/**
	* As many languages use //, provide a default of // style comments.
	*
	* @return "// "
	*/
	protected String getSingleLineCommentToken() {
	return "// ";
	}

	/**
	* As many languages use /, provide a default of / style comments.
	*
	* @return "/*"
	*/
	protected String getMultiLineCommentStartToken() {
	return "/*";
	}

	/**
	* Default block comment end token.
	*
	* @return asterisk, dash
	*/
	protected String getMultiLineCommentEndToken() {
	return "*/";
	}

	@Override
	public String createCommentedString(String comment, boolean addBlockComment) {
	if (addBlockComment) {
	return getMultiLineCommentStartToken() + comment + getMultiLineCommentEndToken();

	} else {
	final String token = getSingleLineCommentToken();
	final Stream<String> split = Pattern.compile("\r?\n").splitAsStream(comment);
	return split.map(s -> token + s).collect(Collectors.joining(System.lineSeparator()));
	}
	}

	@Override
	public String createWrapper(IEnvironment environment, Object instance, String identifier, boolean customNamespace, IScriptEngine engine) {

	if (!customNamespace) {
	// put functions/fields to global namespace
	final StringBuilder scriptCode = new StringBuilder();

	// create wrappers for methods
	for (final Method method : ModuleHelper.getMethods(instance.getClass())) {
	if (isSupportedByLanguage(method)) {

	final String code = createFunctionWrapper(environment, identifier, method);

	if ((code != null) && !code.isEmpty()) {
	scriptCode.append(code);
	scriptCode.append('\n');
	}
	}
	}

	// create wrappers for final fields
	for (final Field field : ModuleHelper.getFields(instance.getClass())) {
	if (isSupportedByLanguage(field)) {
	final String code = createFieldWrapper(environment, identifier, field);

	if ((code != null) && !code.isEmpty()) {
	scriptCode.append(code);
	scriptCode.append('\n');
	}
	}
	}

	return scriptCode.toString();

	} else
	throw new RuntimeException("Object wrappers not supported by default wrapper");
	}

	/**
	* Verify that a method can be wrapped for the current target language.
	*
	* @param method
	* method to be queried
	* @return <code>true</code> when method can be wrapped
	*/
	protected boolean isSupportedByLanguage(Method method) {
	return isSupportedByLanguage(method.getAnnotation(WrapToScript.class));
	}

	/**
	* Verify that a field can be wrapped for the current target language.
	*
	* @param field
	* method to be queried
	* @return <code>true</code> when field can be wrapped
	*/
	protected boolean isSupportedByLanguage(Field field) {
	return isSupportedByLanguage(field.getAnnotation(WrapToScript.class));
	}

	/**
	* Verify that an annotation indicates wrapping support for the current target language.
	*
	* @param annotation
	* annotation to be queried
	* @return <code>true</code> when annotation indicated wrapping support
	*/
	private boolean isSupportedByLanguage(WrapToScript annotation) {
	if (annotation != null) {
	final String languages = annotation.supportedLanguages().trim();
	if (!languages.isEmpty()) {
	final String[] supportedLanguages = languages.split(",");
	if (supportedLanguages[0].startsWith("!")) {
	// exclude pattern
	for (final String language : supportedLanguages) {
	if (language.substring(1).equals(getLanguageIdentifier()))
	return false;
	}

	} else {
	// include pattern
	for (final String language : supportedLanguages) {
	if (language.equals(getLanguageIdentifier()))
	return true;
	}

	return false;
	}
	}
	}

	return true;
	}

	/**
	* Get the language identifier for this code factory.
	*
	* @return language identifier as defined in extension point scriptType.name
	*/
	protected abstract Object getLanguageIdentifier();

	/**
	* Create code for a method wrapper function in the global namespace of the script engine.
	*
	* @param environment
	* environment instance
	* @param identifier
	* function name to be used
	* @param method
	* method to refer to
	* @return script code to be injected into the script engine
	*/
	protected abstract String createFunctionWrapper(IEnvironment environment, String identifier, Method method);

	/**
	* Create code for a field wrapper function in the global namespace of the script engine.
	*
	* @param environment
	* environment instance
	* @param identifier
	* function name to be used
	* @param field
	* field to refer to
	* @return script code to be injected into the script engine
	*/
	protected abstract String createFieldWrapper(IEnvironment environment, String identifier, Field field);

	/**
	* Convert a given name to a script language safe name. To make sure it is safe we check against a list of given keywords. We then append '_' until the
	* value is save.
	*
	* @param name
	* name to check
	* @return safe name
	*/
	protected abstract String toSafeName(String name);
	}