ant/org.eclipse.ant.ui/Ant Editor/org/eclipse/ant/internal/ui/editor/formatter/XmlFormatter.java - platform/eclipse.platform - Git at Google

 /*******************************************************************************
  * Copyright (c) 2004, 2013 John-Mason P. Shackelford and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
  *
  * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     John-Mason P. Shackelford - initial API and implementation
  *     IBM Corporation - bug fixes
  *******************************************************************************/
 package org.eclipse.ant.internal.ui.editor.formatter;

 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;

 import org.eclipse.ant.internal.core.IAntCoreConstants;
 import org.eclipse.ant.internal.ui.editor.templates.AntContext;
 import org.eclipse.ant.internal.ui.editor.text.AntDocumentSetupParticipant;
 import org.eclipse.ant.internal.ui.editor.text.AntEditorPartitionScanner;
 import org.eclipse.ant.internal.ui.model.AntElementNode;
 import org.eclipse.ant.internal.ui.model.AntProjectNode;
 import org.eclipse.ant.internal.ui.model.IAntModel;
 import org.eclipse.core.runtime.Assert;
 import org.eclipse.jface.text.BadLocationException;
 import org.eclipse.jface.text.BadPositionCategoryException;
 import org.eclipse.jface.text.DefaultPositionUpdater;
 import org.eclipse.jface.text.Document;
 import org.eclipse.jface.text.IDocument;
 import org.eclipse.jface.text.IRegion;
 import org.eclipse.jface.text.Position;
 import org.eclipse.jface.text.Region;
 import org.eclipse.jface.text.formatter.MultiPassContentFormatter;
 import org.eclipse.jface.text.templates.TemplateBuffer;
 import org.eclipse.jface.text.templates.TemplateVariable;

 /**
  * Utility class for using the ant code formatter in contexts where an IDocument containing the text to format is not readily available.
  */
 public class XmlFormatter {

 	private static final String POS_CATEGORY = "tempAntFormatterCategory"; //$NON-NLS-1$

 	/**
 	 * Format the text using the ant code formatter.
 	 *
 	 * @param text
 	 *            The text to format. Must be a non-null value.
 	 * @param prefs
 	 *            Preferences to use for this format operation. If null, the preferences currently set in the plug-in's preferences store are used.
 	 * @return The formatted text.
 	 */
 	public static String format(String text, FormattingPreferences prefs) {

 		return format(text, prefs, -1);
 	}

 	private static String format(String text, FormattingPreferences prefs, int indent) {
 		Assert.isNotNull(text);

 		FormattingPreferences applyPrefs;
 		if (prefs == null) {
 			applyPrefs = new FormattingPreferences();
 		} else {
 			applyPrefs = prefs;
 		}

 		IDocument doc = new Document();
 		doc.set(text);
 		new AntDocumentSetupParticipant().setup(doc);

 		format(applyPrefs, doc, indent);

 		return doc.get();
 	}

 	private static void format(FormattingPreferences prefs, IDocument doc, int indent) {
 		MultiPassContentFormatter formatter = new MultiPassContentFormatter(AntDocumentSetupParticipant.ANT_PARTITIONING, IDocument.DEFAULT_CONTENT_TYPE);

 		formatter.setMasterStrategy(new XmlDocumentFormattingStrategy(prefs, indent));
 		formatter.setSlaveStrategy(new XmlElementFormattingStrategy(prefs), AntEditorPartitionScanner.XML_TAG);
 		formatter.format(doc, new Region(0, doc.getLength()));
 	}

 	/**
 	 * Format the text using the ant code formatter using the preferences settings in the plug-in preference store.
 	 *
 	 * @param text
 	 *            The text to format. Must be a non-null value.
 	 * @return The formatted text.
 	 */
 	public static String format(String text) {
 		return format(text, null);
 	}

 	public static void format(TemplateBuffer templateBuffer, AntContext antContext, FormattingPreferences prefs) {
 		String templateString = templateBuffer.getString();
 		IDocument fullDocument = new Document(antContext.getDocument().get());

 		int completionOffset = antContext.getCompletionOffset();
 		try {
 			// trim any starting whitespace
 			IRegion lineRegion = fullDocument.getLineInformationOfOffset(completionOffset);
 			String lineString = fullDocument.get(lineRegion.getOffset(), lineRegion.getLength());
 			lineString = trimBegin(lineString);
 			fullDocument.replace(lineRegion.getOffset(), lineRegion.getLength(), lineString);
 		}
 		catch (BadLocationException e1) {
 			return;
 		}
 		TemplateVariable[] variables = templateBuffer.getVariables();
 		int[] offsets = variablesToOffsets(variables, completionOffset);

 		IDocument origTemplateDoc = new Document(fullDocument.get());
 		try {
 			origTemplateDoc.replace(completionOffset, antContext.getCompletionLength(), templateString);
 		}
 		catch (BadLocationException e) {
 			return; // don't format if the document has changed
 		}

 		IDocument templateDocument = createDocument(origTemplateDoc.get(), createPositions(offsets));

 		String leadingText = getLeadingText(fullDocument, antContext.getAntModel(), completionOffset);
 		String newTemplateString = leadingText + templateString;
 		int indent = XmlDocumentFormatter.computeIndent(leadingText, prefs.getTabWidth());

 		newTemplateString = format(newTemplateString, prefs, indent);

 		try {
 			templateDocument.replace(completionOffset, templateString.length(), newTemplateString);
 		}
 		catch (BadLocationException e) {
 			return;
 		}
 		Position[] positions = null;
 		try {
 			positions = templateDocument.getPositions(POS_CATEGORY);
 		}
 		catch (BadPositionCategoryException e2) {
 			// do nothing
 		}
 		// offsetsToVariables(offsets, variables, completionOffset);
 		positionsToVariables(positions, variables, completionOffset);
 		templateBuffer.setContent(newTemplateString, variables);
 	}

 	private static void positionsToVariables(Position[] positions, TemplateVariable[] variables, int start) {
 		for (int i = 0; i != variables.length; i++) {
 			TemplateVariable variable = variables[i];

 			int[] offsets = new int[variable.getOffsets().length];
 			for (int j = 0; j != offsets.length; j++) {
 				offsets[j] = positions[j].getOffset() - start;
 			}

 			variable.setOffsets(offsets);
 		}
 	}

 	private static Document createDocument(String string, Position[] positions) throws IllegalArgumentException {
 		Document doc = new Document(string);
 		try {
 			if (positions != null) {

 				doc.addPositionCategory(POS_CATEGORY);
 				doc.addPositionUpdater(new DefaultPositionUpdater(POS_CATEGORY) {
 					@Override
 					protected boolean notDeleted() {
 						if (fOffset < fPosition.offset && (fPosition.offset + fPosition.length < fOffset + fLength)) {
 							fPosition.offset = fOffset + fLength; // deleted positions: set to end of remove
 							return false;
 						}
 						return true;
 					}
 				});
 				for (int i = 0; i < positions.length; i++) {
 					try {
 						doc.addPosition(POS_CATEGORY, positions[i]);
 					}
 					catch (BadLocationException e) {
 						throw new IllegalArgumentException("Position outside of string. offset: " + positions[i].offset + ", length: " //$NON-NLS-1$//$NON-NLS-2$
 								+ positions[i].length + ", string size: " + string.length(), e); //$NON-NLS-1$
 					}
 				}
 			}
 		}
 		catch (BadPositionCategoryException cannotHappen) {
 			// can not happen: category is correctly set up
 		}
 		return doc;
 	}

 	public static String trimBegin(String toBeTrimmed) {

 		int i = 0;
 		while ((i != toBeTrimmed.length()) && Character.isWhitespace(toBeTrimmed.charAt(i))) {
 			i++;
 		}

 		return toBeTrimmed.substring(i);
 	}

 	private static int[] variablesToOffsets(TemplateVariable[] variables, int start) {
 		List<Integer> list = new ArrayList<>();
 		for (int i = 0; i != variables.length; i++) {
 			int[] offsets = variables[i].getOffsets();
 			for (int j = 0; j != offsets.length; j++) {
 				list.add(Integer.valueOf(offsets[j]));
 			}
 		}

 		int[] offsets = new int[list.size()];
 		for (int i = 0; i != offsets.length; i++) {
 			offsets[i] = list.get(i).intValue() + start;
 		}

 		Arrays.sort(offsets);

 		return offsets;
 	}

 	/**
 	 * Returns the indentation level at the position of code completion.
 	 */
 	private static String getLeadingText(IDocument document, IAntModel model, int completionOffset) {
 		AntProjectNode project = model.getProjectNode(false);
 		if (project == null) {
 			return IAntCoreConstants.EMPTY_STRING;
 		}
 		AntElementNode node = project.getNode(completionOffset);// - fAccumulatedChange);
 		if (node == null) {
 			return IAntCoreConstants.EMPTY_STRING;
 		}

 		StringBuffer buf = new StringBuffer();
 		buf.append(XmlDocumentFormatter.getLeadingWhitespace(node.getOffset(), document));
 		buf.append(XmlDocumentFormatter.createIndent());
 		return buf.toString();
 	}

 	private static Position[] createPositions(int[] positions) {
 		Position[] p = null;

 		if (positions != null) {
 			p = new Position[positions.length];
 			for (int i = 0; i < positions.length; i++) {
 				p[i] = new Position(positions[i], 0);
 			}
 		}
 		return p;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2004, 2013 John-Mason P. Shackelford and others.
	*
	* This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License 2.0
	* which accompanies this distribution, and is available at
	* https://www.eclipse.org/legal/epl-2.0/
	*
	* SPDX-License-Identifier: EPL-2.0
	*
	* Contributors:
	* John-Mason P. Shackelford - initial API and implementation
	* IBM Corporation - bug fixes
	*******************************************************************************/
	package org.eclipse.ant.internal.ui.editor.formatter;

	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.List;

	import org.eclipse.ant.internal.core.IAntCoreConstants;
	import org.eclipse.ant.internal.ui.editor.templates.AntContext;
	import org.eclipse.ant.internal.ui.editor.text.AntDocumentSetupParticipant;
	import org.eclipse.ant.internal.ui.editor.text.AntEditorPartitionScanner;
	import org.eclipse.ant.internal.ui.model.AntElementNode;
	import org.eclipse.ant.internal.ui.model.AntProjectNode;
	import org.eclipse.ant.internal.ui.model.IAntModel;
	import org.eclipse.core.runtime.Assert;
	import org.eclipse.jface.text.BadLocationException;
	import org.eclipse.jface.text.BadPositionCategoryException;
	import org.eclipse.jface.text.DefaultPositionUpdater;
	import org.eclipse.jface.text.Document;
	import org.eclipse.jface.text.IDocument;
	import org.eclipse.jface.text.IRegion;
	import org.eclipse.jface.text.Position;
	import org.eclipse.jface.text.Region;
	import org.eclipse.jface.text.formatter.MultiPassContentFormatter;
	import org.eclipse.jface.text.templates.TemplateBuffer;
	import org.eclipse.jface.text.templates.TemplateVariable;

	/**
	* Utility class for using the ant code formatter in contexts where an IDocument containing the text to format is not readily available.
	*/
	public class XmlFormatter {

	private static final String POS_CATEGORY = "tempAntFormatterCategory"; //$NON-NLS-1$

	/**
	* Format the text using the ant code formatter.
	*
	* @param text
	* The text to format. Must be a non-null value.
	* @param prefs
	* Preferences to use for this format operation. If null, the preferences currently set in the plug-in's preferences store are used.
	* @return The formatted text.
	*/
	public static String format(String text, FormattingPreferences prefs) {

	return format(text, prefs, -1);
	}

	private static String format(String text, FormattingPreferences prefs, int indent) {
	Assert.isNotNull(text);

	FormattingPreferences applyPrefs;
	if (prefs == null) {
	applyPrefs = new FormattingPreferences();
	} else {
	applyPrefs = prefs;
	}

	IDocument doc = new Document();
	doc.set(text);
	new AntDocumentSetupParticipant().setup(doc);

	format(applyPrefs, doc, indent);

	return doc.get();
	}

	private static void format(FormattingPreferences prefs, IDocument doc, int indent) {
	MultiPassContentFormatter formatter = new MultiPassContentFormatter(AntDocumentSetupParticipant.ANT_PARTITIONING, IDocument.DEFAULT_CONTENT_TYPE);

	formatter.setMasterStrategy(new XmlDocumentFormattingStrategy(prefs, indent));
	formatter.setSlaveStrategy(new XmlElementFormattingStrategy(prefs), AntEditorPartitionScanner.XML_TAG);
	formatter.format(doc, new Region(0, doc.getLength()));
	}

	/**
	* Format the text using the ant code formatter using the preferences settings in the plug-in preference store.
	*
	* @param text
	* The text to format. Must be a non-null value.
	* @return The formatted text.
	*/
	public static String format(String text) {
	return format(text, null);
	}

	public static void format(TemplateBuffer templateBuffer, AntContext antContext, FormattingPreferences prefs) {
	String templateString = templateBuffer.getString();
	IDocument fullDocument = new Document(antContext.getDocument().get());

	int completionOffset = antContext.getCompletionOffset();
	try {
	// trim any starting whitespace
	IRegion lineRegion = fullDocument.getLineInformationOfOffset(completionOffset);
	String lineString = fullDocument.get(lineRegion.getOffset(), lineRegion.getLength());
	lineString = trimBegin(lineString);
	fullDocument.replace(lineRegion.getOffset(), lineRegion.getLength(), lineString);
	}
	catch (BadLocationException e1) {
	return;
	}
	TemplateVariable[] variables = templateBuffer.getVariables();
	int[] offsets = variablesToOffsets(variables, completionOffset);

	IDocument origTemplateDoc = new Document(fullDocument.get());
	try {
	origTemplateDoc.replace(completionOffset, antContext.getCompletionLength(), templateString);
	}
	catch (BadLocationException e) {
	return; // don't format if the document has changed
	}

	IDocument templateDocument = createDocument(origTemplateDoc.get(), createPositions(offsets));

	String leadingText = getLeadingText(fullDocument, antContext.getAntModel(), completionOffset);
	String newTemplateString = leadingText + templateString;
	int indent = XmlDocumentFormatter.computeIndent(leadingText, prefs.getTabWidth());

	newTemplateString = format(newTemplateString, prefs, indent);

	try {
	templateDocument.replace(completionOffset, templateString.length(), newTemplateString);
	}
	catch (BadLocationException e) {
	return;
	}
	Position[] positions = null;
	try {
	positions = templateDocument.getPositions(POS_CATEGORY);
	}
	catch (BadPositionCategoryException e2) {
	// do nothing
	}
	// offsetsToVariables(offsets, variables, completionOffset);
	positionsToVariables(positions, variables, completionOffset);
	templateBuffer.setContent(newTemplateString, variables);
	}

	private static void positionsToVariables(Position[] positions, TemplateVariable[] variables, int start) {
	for (int i = 0; i != variables.length; i++) {
	TemplateVariable variable = variables[i];

	int[] offsets = new int[variable.getOffsets().length];
	for (int j = 0; j != offsets.length; j++) {
	offsets[j] = positions[j].getOffset() - start;
	}

	variable.setOffsets(offsets);
	}
	}

	private static Document createDocument(String string, Position[] positions) throws IllegalArgumentException {
	Document doc = new Document(string);
	try {
	if (positions != null) {

	doc.addPositionCategory(POS_CATEGORY);
	doc.addPositionUpdater(new DefaultPositionUpdater(POS_CATEGORY) {
	@Override
	protected boolean notDeleted() {
	if (fOffset < fPosition.offset && (fPosition.offset + fPosition.length < fOffset + fLength)) {
	fPosition.offset = fOffset + fLength; // deleted positions: set to end of remove
	return false;
	}
	return true;
	}
	});
	for (int i = 0; i < positions.length; i++) {
	try {
	doc.addPosition(POS_CATEGORY, positions[i]);
	}
	catch (BadLocationException e) {
	throw new IllegalArgumentException("Position outside of string. offset: " + positions[i].offset + ", length: " //$NON-NLS-1$//$NON-NLS-2$
	+ positions[i].length + ", string size: " + string.length(), e); //$NON-NLS-1$
	}
	}
	}
	}
	catch (BadPositionCategoryException cannotHappen) {
	// can not happen: category is correctly set up
	}
	return doc;
	}

	public static String trimBegin(String toBeTrimmed) {

	int i = 0;
	while ((i != toBeTrimmed.length()) && Character.isWhitespace(toBeTrimmed.charAt(i))) {
	i++;
	}

	return toBeTrimmed.substring(i);
	}

	private static int[] variablesToOffsets(TemplateVariable[] variables, int start) {
	List<Integer> list = new ArrayList<>();
	for (int i = 0; i != variables.length; i++) {
	int[] offsets = variables[i].getOffsets();
	for (int j = 0; j != offsets.length; j++) {
	list.add(Integer.valueOf(offsets[j]));
	}
	}

	int[] offsets = new int[list.size()];
	for (int i = 0; i != offsets.length; i++) {
	offsets[i] = list.get(i).intValue() + start;
	}

	Arrays.sort(offsets);

	return offsets;
	}

	/**
	* Returns the indentation level at the position of code completion.
	*/
	private static String getLeadingText(IDocument document, IAntModel model, int completionOffset) {
	AntProjectNode project = model.getProjectNode(false);
	if (project == null) {
	return IAntCoreConstants.EMPTY_STRING;
	}
	AntElementNode node = project.getNode(completionOffset);// - fAccumulatedChange);
	if (node == null) {
	return IAntCoreConstants.EMPTY_STRING;
	}

	StringBuffer buf = new StringBuffer();
	buf.append(XmlDocumentFormatter.getLeadingWhitespace(node.getOffset(), document));
	buf.append(XmlDocumentFormatter.createIndent());
	return buf.toString();
	}

	private static Position[] createPositions(int[] positions) {
	Position[] p = null;

	if (positions != null) {
	p = new Position[positions.length];
	for (int i = 0; i < positions.length; i++) {
	p[i] = new Position(positions[i], 0);
	}
	}
	return p;
	}
	}