plugins/org.eclipse.dltk.javascript.ui/src/org/eclipse/dltk/javascript/internal/ui/templates/JavaScriptTemplateContext.java

/*******************************************************************************
 * Copyright (c) 2005, 2007 IBM Corporation 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
 *
 
 *******************************************************************************/
package org.eclipse.dltk.javascript.internal.ui.templates;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.eclipse.dltk.core.ISourceModule;
import org.eclipse.dltk.javascript.ast.MultiLineComment;
import org.eclipse.dltk.javascript.ast.PropertyInitializer;
import org.eclipse.dltk.javascript.core.JavaScriptNature;
import org.eclipse.dltk.javascript.internal.core.codeassist.JavaScriptCompletionUtil;
import org.eclipse.dltk.javascript.internal.core.codeassist.JavaScriptCompletionUtil.ExpressionContext;
import org.eclipse.dltk.javascript.internal.core.codeassist.JavaScriptCompletionUtil.ExpressionType;
import org.eclipse.dltk.javascript.internal.ui.JavaScriptUI;
import org.eclipse.dltk.ui.formatter.FormatterException;
import org.eclipse.dltk.ui.formatter.FormatterSyntaxProblemException;
import org.eclipse.dltk.ui.formatter.IScriptFormatter;
import org.eclipse.dltk.ui.formatter.IScriptFormatterFactory;
import org.eclipse.dltk.ui.formatter.ScriptFormatterManager;
import org.eclipse.dltk.ui.templates.ScriptTemplateContext;
import org.eclipse.dltk.ui.text.DocumentUtils;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.Position;
import org.eclipse.jface.text.TextUtilities;
import org.eclipse.jface.text.templates.GlobalTemplateVariables;
import org.eclipse.jface.text.templates.Template;
import org.eclipse.jface.text.templates.TemplateBuffer;
import org.eclipse.jface.text.templates.TemplateContextType;
import org.eclipse.jface.text.templates.TemplateException;
import org.eclipse.jface.text.templates.TemplateVariable;
import org.eclipse.text.edits.TextEdit;

public class JavaScriptTemplateContext extends ScriptTemplateContext {

	public JavaScriptTemplateContext(TemplateContextType type,
			IDocument document, int completionOffset, int completionLength,
			ISourceModule sourceModule) {
		super(type, document, completionOffset, completionLength, sourceModule);
	}

	public JavaScriptTemplateContext(TemplateContextType type,
			IDocument document, Position position, ISourceModule sourceModule) {
		super(type, document, position, sourceModule);
	}

	@Override
	public TemplateBuffer evaluate(Template template)
			throws BadLocationException, TemplateException {
		if (!canEvaluate(template)) {
			return null;
		}
		final IScriptFormatterFactory factory = ScriptFormatterManager
				.getSelected(JavaScriptNature.NATURE_ID, getSourceModule()
						.getScriptProject().getProject());
		if (factory != null) {
			final IScriptFormatter formatter = factory.createFormatter(
					TextUtilities.getDefaultLineDelimiter(getDocument()),
					factory.retrievePreferences(getPreferences()));
			try {
				final Map<String, String> rememberedVariables = new HashMap<String, String>();
				final String encoded = encodeVariables(template.getPattern(),
						rememberedVariables);
				final TextEdit edit = formatter.format(encoded, 0,
						encoded.length(), 0);
				if (edit != null) {
					final Document document = new Document(encoded);
					edit.apply(document);
					template = new Template(template.getName(),
							template.getDescription(),
							template.getContextTypeId(), restoreVariables(
									document.get(), rememberedVariables),
							template.isAutoInsertable());
				}
			} catch (FormatterSyntaxProblemException e) {
				// ignore & & fall thru
			} catch (FormatterException e) {
				JavaScriptUI.log(e);
			}
		}
		final TemplateBuffer templateBuffer = super.evaluate(template);
		if (templateBuffer != null
				&& !isReadOnly()
				&& templateBuffer.getString().startsWith(
						MultiLineComment.JSDOC_PREFIX)) {
			final ExpressionContext expressionContext = JavaScriptCompletionUtil
					.evaluateExpressionContext(getSourceModule(),
							DocumentUtils.asCharSequence(getDocument()),
							getEnd());
			if (expressionContext != null
					&& expressionContext.expressionType == ExpressionType.PROPERTY_INITIALIZER_VALUE) {
				final String replacement = templateBuffer.getString();
				int docEnd = replacement
						.indexOf(JavaScriptTemplateProposal.C_END);
				if (docEnd > 0) {
					docEnd += JavaScriptTemplateProposal.C_END.length();
					final PropertyInitializer propertyInitializer = (PropertyInitializer) expressionContext.node
							.getParent();

					final String doc = replacement.substring(0, docEnd)
							+ TextUtilities
									.getDefaultLineDelimiter(getDocument())
							+ calculateIndent(getDocument(),
									propertyInitializer.start());

					while (docEnd + 1 < replacement.length()
							&& Character.isWhitespace(replacement
									.charAt(docEnd))) {
						++docEnd;
					}
					if (propertyInitializer.getName().getDocumentation() != null) {
						templateBuffer.setContent(
								replacement.substring(docEnd),
								filterTemplateVariables(
										templateBuffer.getVariables(), docEnd));
					} else {
						final int docOffset = getStart()
								- propertyInitializer.start() + doc.length();
						getDocument().replace(propertyInitializer.start(), 0,
								doc);
						setCompletionOffset(getCompletionOffset()
								+ doc.length());
						for (TemplateVariable variable : templateBuffer
								.getVariables()) {
							int[] offsets = variable.getOffsets();
							for (int i = 0; i < offsets.length; ++i) {
								if (offsets[i] < docEnd) {
									offsets[i] -= docOffset;
								} else {
									offsets[i] -= docEnd;
								}
							}
						}
						templateBuffer.setContent(
								replacement.substring(docEnd),
								templateBuffer.getVariables());
					}
				}
			}
		}
		return templateBuffer;
	}

	private TemplateVariable[] filterTemplateVariables(
			TemplateVariable[] variables, int offset) {
		List<TemplateVariable> result = new ArrayList<TemplateVariable>(
				variables.length);
		for (TemplateVariable variable : variables) {
			int[] offsets = filterOffsets(variable.getOffsets(), offset);
			if (offsets != null) {
				variable.setOffsets(offsets);
				result.add(variable);
			}
		}
		return result.toArray(new TemplateVariable[result.size()]);
	}

	private int[] filterOffsets(int[] offsets, int offset) {
		int[] result = new int[offset];
		int count = 0;
		for (int i = 0; i < offsets.length; ++i) {
			if (offsets[i] >= offset) {
				result[count++] -= offsets[i] - offset;
			}
		}
		if (count == 0) {
			return null;
		} else if (count == result.length) {
			return result;
		} else {
			int[] newResult = new int[count];
			System.arraycopy(result, 0, newResult, 0, count);
			return newResult;
		}
	}

	/**
	 * Temporary replace variables with unique keys, so variables would not
	 * cause parsing errors during formatting.
	 * 
	 * @param content
	 * @param variables
	 * @return
	 */
	private static String encodeVariables(String content,
			Map<String, String> variables) {
		final StringBuilder bf = new StringBuilder(content.length() * 2);
		boolean in = false;
		final String prefix = "specialSecret12435Id";
		int r = 0;
		int pos = -1;
		for (int a = 0; a < content.length(); a++) {
			char c = content.charAt(a);
			if (c == '$') {
				if (a < content.length() - 1)
					if (content.charAt(a + 1) == '{') {
						in = true;
						pos = a;
					}
			} else if (in) {
				if (c == '}') {
					String variableValue = content.substring(pos, a + 1);
					String variableKey = prefix + r++;
					if (variableValue.equals("${"
							+ GlobalTemplateVariables.Cursor.NAME + "}")) {
						variableKey = "/*" + variableKey + "*/";
					}
					bf.append(variableKey);
					variables.put(variableKey, variableValue);
					in = false;
				}
			} else if (!in) {
				bf.append(c);
			}
		}
		return bf.toString();
	}

	private static String restoreVariables(String value,
			Map<String, String> variables) {
		String formatted = value;
		for (Map.Entry<String, String> entry : variables.entrySet()) {
			formatted = replaceSeq(formatted, entry.getKey(), entry.getValue());
		}
		return formatted;
	}

	private static String replaceSeq(String sq, String target,
			String replacement) {
		// return Pattern.compile(target.toString(), Pattern.LITERAL).matcher(
		// sq).replaceAll(Matcher.quoteReplacement(replacement.toString()));
		int indexOf = sq.indexOf(target);
		while (indexOf != -1) {
			sq = sq.substring(0, indexOf) + replacement
					+ sq.substring(indexOf + target.length());
			indexOf = sq.indexOf(target);
		}
		return sq;
	}
}