plugins/org.eclipse.dltk.sh.ui/src/org/eclipse/dltk/sh/internal/ui/text/ScriptAutoIndentStrategy.java - dltk/org.eclipse.dltk.sh - Git at Google

 /*******************************************************************************
  * Copyright (c) 2009, 2017 Red Hat Inc. 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:
  *     Alexander Kurtakov - initial API and implementation
  *     Mat Booth
  *******************************************************************************/
 package org.eclipse.dltk.sh.internal.ui.text;

 import org.eclipse.dltk.sh.internal.ui.Activator;
 import org.eclipse.dltk.ui.CodeFormatterConstants;
 import org.eclipse.jface.preference.IPreferenceStore;
 import org.eclipse.jface.text.BadLocationException;
 import org.eclipse.jface.text.DocumentCommand;
 import org.eclipse.jface.text.IAutoEditStrategy;
 import org.eclipse.jface.text.IDocument;
 import org.eclipse.jface.text.TextUtilities;
 import org.eclipse.jface.text.rules.IRule;
 import org.eclipse.jface.text.rules.IToken;

 /**
  * An indent strategy capable of indenting and unindenting on any set of words,
  * depending on the rules that are set.
  *
  * @see #setRules(IRule[])
  */
 public class ScriptAutoIndentStrategy implements IAutoEditStrategy {
 	/**
 	 * Document scanner used to identify indentations.
 	 */
 	private final DocumentAndCommandScanner scanner = new DocumentAndCommandScanner();

 	/**
 	 * Set the rules that will be used in a document scanner to identify where
 	 * indentations should occur. Typically you'd have one rule to describe each
 	 * type of indentation.
 	 *
 	 * @param rules
 	 *            the list of rules
 	 * @see IndentType
 	 */
 	public void setRules(IRule[] rules) {
 		scanner.setRules(rules);
 	}

 	/**
 	 * This implementation attempts to auto-indent and auto-unindent after keywords
 	 * that require it.
 	 */
 	@Override
 	public void customizeDocumentCommand(IDocument d, DocumentCommand c) {
 		int delim = TextUtilities.endsWith(d.getLegalLineDelimiters(), c.text);
 		if ((c.length == 0) && (c.text != null) && (delim != -1)) {
 			smartIndentAfterNewLine(d, c);
 		} else if ((c.text.length() == 1) && !c.text.equals("#")) {
 			smartIndentAfterKeypress(d, c);
 		}
 	}

 	/**
 	 * Set the indent of a new line when the user hits carriage return. The new
 	 * indent will either be the same as the previous line or incremented if the
 	 * user has hit carriage return on a line that contains a incrementing keyword.
 	 *
 	 * @param document
 	 *            the document being parsed
 	 * @param c
 	 *            the command being performed
 	 */
 	protected void smartIndentAfterNewLine(IDocument document, DocumentCommand c) {
 		if ((c.offset == -1) || (document.getLength() == 0)) {
 			return;
 		}
 		try {
 			StringBuilder buf = new StringBuilder(c.text);
 			int p = c.offset == document.getLength() ? c.offset - 1 : c.offset;
 			int line = document.getLineOfOffset(p);
 			int start = document.getLineOffset(line);
 			int bracketCount = getBracketCount(document, null, start, c.offset, true);
 			buf.append(generateIndentation(getIndentOfLine(document, line), bracketCount <= 0 ? 0 : 1));
 			c.text = buf.toString();
 		} catch (BadLocationException x) {
 			// ignore
 		}
 	}

 	/**
 	 * Set the indent of the current line when the user hits a key. The indent will
 	 * either be unchanged or decremented if the user types
 	 *
 	 * @param document
 	 *            the document being parsed
 	 * @param c
 	 *            the command being performed
 	 */
 	protected void smartIndentAfterKeypress(IDocument document, DocumentCommand c) {
 		if ((c.offset == -1) || (document.getLength() == 0) || c.text.trim().isEmpty()) {
 			return;
 		}
 		try {
 			StringBuilder buf = new StringBuilder();
 			int p = c.offset == document.getLength() ? c.offset - 1 : c.offset;
 			int line = document.getLineOfOffset(p);
 			int start = document.getLineOffset(line);
 			int whiteEnd = findEndOfWhiteSpace(document, start, c.offset);

 			int bracketCount = getBracketCount(document, c, start, c.offset, false);
 			buf.append(generateIndentation(getIndentOfLine(document, line), bracketCount >= 0 ? 0 : -1));
 			buf.append(document.get(whiteEnd, c.offset - whiteEnd));
 			buf.append(c.text);
 			// Alter the command
 			c.length = (c.offset - start) + c.length;
 			c.offset = start;
 			c.text = buf.toString();
 		} catch (BadLocationException x) {
 			// ignore
 		}
 	}

 	/**
 	 * Returns the first offset greater than <code>offset</code> and smaller than
 	 * <code>end</code> whose character is not a space or tab character. If no such
 	 * offset is found, <code>end</code> is returned.
 	 *
 	 * @param document
 	 *            the document to search in
 	 * @param offset
 	 *            the offset at which searching start
 	 * @param end
 	 *            the offset at which searching stops
 	 * @return the offset in the specified range whose character is not a space or
 	 *         tab
 	 * @exception BadLocationException
 	 *                if offset is an invalid position in the given document
 	 */
 	private static int findEndOfWhiteSpace(IDocument document, int offset, int end) throws BadLocationException {
 		while (offset < end) {
 			char c = document.getChar(offset);
 			if ((c != ' ') && (c != '\t')) {
 				return offset;
 			}
 			offset++;
 		}
 		return end;
 	}

 	/**
 	 * Returns the indentation of the specified line in <code>document</code>.
 	 *
 	 * @param document
 	 *            - the document being parsed
 	 * @param line
 	 *            - the line number being searched
 	 * @return the string containing the indentation from the specified line
 	 */
 	private static String getIndentOfLine(IDocument document, int line) throws BadLocationException {
 		if (line > -1) {
 			int start = document.getLineOffset(line);
 			int end = start + document.getLineLength(line);
 			int whiteend = findEndOfWhiteSpace(document, start, end);
 			return document.get(start, whiteend - start);
 		} else {
 			return "";
 		}
 	}

 	/**
 	 * Returns the bracket count of a section of text. The count is incremented when
 	 * an opening bracket is encountered and decremented when a closing bracket is
 	 * encountered.
 	 *
 	 * @param document
 	 *            - the document being parsed
 	 * @param command
 	 *            - if not null, the inserted text specified by the command will be
 	 *            taken into account as if it were part of the document
 	 * @param start
 	 *            - the start position for the search
 	 * @param end
 	 *            - the end position for the search
 	 * @param ignoreInflexions
 	 *            - whether or not to ignore inflexions in the count
 	 * @return the resulting bracket count, a positive value means we've encountered
 	 *         more opening than closing brackets
 	 */
 	private int getBracketCount(IDocument document, DocumentCommand command, int start, int end,
 			boolean ignoreInflexions) {
 		int bracketcount = 0;
 		if (command != null) {
 			scanner.setRange(document, command, start, end - start);
 		} else {
 			scanner.setRange(document, start, end - start);
 		}

 		while (true) {
 			IToken token = scanner.nextToken();
 			if (token.isEOF()) {
 				break;
 			}

 			if (token.isOther()) {
 				IndentType type = (IndentType) token.getData();
 				if (type == IndentType.INCREMENT) {
 					++bracketcount;
 				} else if (type == IndentType.DECREMENT) {
 					--bracketcount;
 				} else if ((type == IndentType.INFLEXION) && ignoreInflexions) {
 					++bracketcount;
 				} else if ((type == IndentType.INFLEXION) && !ignoreInflexions) {
 					--bracketcount;
 				}
 			}
 		}
 		return bracketcount;
 	}

 	/**
 	 * Calculate the indentation needed for a new line based on the contents of the
 	 * previous line.
 	 *
 	 * @param previous
 	 *            a string containing the indentation of the previous line
 	 * @param additional
 	 *            number of desired addition indentations, may be negative
 	 * @return a string containing the indentation to use on the new line
 	 */
 	private static String generateIndentation(String previous, int additional) {
 		// Get the indentation preferences
 		IPreferenceStore prefs = Activator.getDefault().getPreferenceStore();
 		String tabChar = prefs.getString(CodeFormatterConstants.FORMATTER_TAB_CHAR);
 		int indentSize = prefs.getInt(CodeFormatterConstants.FORMATTER_INDENTATION_SIZE);
 		int tabSize = prefs.getInt(CodeFormatterConstants.FORMATTER_TAB_SIZE);

 		// Size in characters of the indentation of the previous line
 		int preLength = computeVisualLength(previous, tabSize);

 		// Number of addition characters needed
 		int addLength = indentSize * additional;

 		// Target size of the indentation for the new line
 		int endLength = Math.max(0, preLength + addLength);

 		// Trim previous indentation back to nearest tab stop
 		int minLength = Math.min(endLength, preLength);
 		// indent
 		// to
 		// copy
 		String indent = stripExtraChars(previous, minLength, tabSize);

 		// Add additional indentation
 		int missing = endLength - minLength;
 		final int tabs, spaces;
 		if (CodeFormatterConstants.SPACE.equals(tabChar)) {
 			// Each indent is a number of spaces equal to indent size
 			tabs = 0;
 			spaces = missing;
 		} else if (CodeFormatterConstants.TAB.equals(tabChar)) {
 			// Missing should always be in multiples of indent size, so this
 			// means "one tab per indent" and indent size is essentially ignored
 			tabs = missing / indentSize;
 			spaces = 0;
 		} else if (CodeFormatterConstants.MIXED.equals(tabChar)) {
 			// If the missing indent is a multiple of tab size then tabs will be
 			// used, otherwise use spaces
 			tabs = tabSize > 0 ? missing / tabSize : 0;
 			spaces = tabSize > 0 ? missing % tabSize : missing;
 		} else {
 			tabs = 0;
 			spaces = 0;
 		}
 		for (int i = 0; i < tabs; i++) {
 			indent += "\t";
 		}
 		for (int i = 0; i < spaces; i++) {
 			indent += " ";
 		}
 		return indent;
 	}

 	/**
 	 * Computes the length of a an indentation, counting a tab character as the size
 	 * until the next tab stop and every other character as one.
 	 *
 	 * @param indent
 	 *            the string containing the indentation to measure
 	 * @param tabSize
 	 *            the visual size of tab characters
 	 * @return the visual length in number of characters
 	 */
 	private static int computeVisualLength(String indent, int tabSize) {
 		int length = 0;
 		for (int i = 0; i < indent.length(); i++) {
 			char ch = indent.charAt(i);
 			switch (ch) {
 			case '\t':
 				if (tabSize > 0) {
 					length += tabSize;
 				}
 				break;
 			case ' ':
 				length++;
 				break;
 			}
 		}
 		return length;
 	}

 	/**
 	 * Strips any characters off the end of an indentation that exceed a specified
 	 * maximum visual indentation length.
 	 *
 	 * @param indent
 	 *            the string containing the indentation to measure
 	 * @param max
 	 *            the maximum visual indentation length
 	 * @param tabSize
 	 *            the visual size of tab characters
 	 * @return a string containing the stripped indentation
 	 */
 	private static String stripExtraChars(String indent, int max, int tabSize) {
 		int measured = 0;
 		int i = 0;
 		for (; (measured < max) && (i < indent.length()); i++) {
 			char ch = indent.charAt(i);
 			switch (ch) {
 			case '\t':
 				if (tabSize > 0) {
 					int reminder = measured % tabSize;
 					measured += tabSize - reminder;
 				}
 				break;
 			case ' ':
 				measured++;
 				break;
 			}
 		}
 		return indent.substring(0, measured > max ? i - 1 : i);
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2009, 2017 Red Hat Inc. 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:
	* Alexander Kurtakov - initial API and implementation
	* Mat Booth
	*******************************************************************************/
	package org.eclipse.dltk.sh.internal.ui.text;

	import org.eclipse.dltk.sh.internal.ui.Activator;
	import org.eclipse.dltk.ui.CodeFormatterConstants;
	import org.eclipse.jface.preference.IPreferenceStore;
	import org.eclipse.jface.text.BadLocationException;
	import org.eclipse.jface.text.DocumentCommand;
	import org.eclipse.jface.text.IAutoEditStrategy;
	import org.eclipse.jface.text.IDocument;
	import org.eclipse.jface.text.TextUtilities;
	import org.eclipse.jface.text.rules.IRule;
	import org.eclipse.jface.text.rules.IToken;

	/**
	* An indent strategy capable of indenting and unindenting on any set of words,
	* depending on the rules that are set.
	*
	* @see #setRules(IRule[])
	*/
	public class ScriptAutoIndentStrategy implements IAutoEditStrategy {
	/**
	* Document scanner used to identify indentations.
	*/
	private final DocumentAndCommandScanner scanner = new DocumentAndCommandScanner();

	/**
	* Set the rules that will be used in a document scanner to identify where
	* indentations should occur. Typically you'd have one rule to describe each
	* type of indentation.
	*
	* @param rules
	* the list of rules
	* @see IndentType
	*/
	public void setRules(IRule[] rules) {
	scanner.setRules(rules);
	}

	/**
	* This implementation attempts to auto-indent and auto-unindent after keywords
	* that require it.
	*/
	@Override
	public void customizeDocumentCommand(IDocument d, DocumentCommand c) {
	int delim = TextUtilities.endsWith(d.getLegalLineDelimiters(), c.text);
	if ((c.length == 0) && (c.text != null) && (delim != -1)) {
	smartIndentAfterNewLine(d, c);
	} else if ((c.text.length() == 1) && !c.text.equals("#")) {
	smartIndentAfterKeypress(d, c);
	}
	}

	/**
	* Set the indent of a new line when the user hits carriage return. The new
	* indent will either be the same as the previous line or incremented if the
	* user has hit carriage return on a line that contains a incrementing keyword.
	*
	* @param document
	* the document being parsed
	* @param c
	* the command being performed
	*/
	protected void smartIndentAfterNewLine(IDocument document, DocumentCommand c) {
	if ((c.offset == -1) \|\| (document.getLength() == 0)) {
	return;
	}
	try {
	StringBuilder buf = new StringBuilder(c.text);
	int p = c.offset == document.getLength() ? c.offset - 1 : c.offset;
	int line = document.getLineOfOffset(p);
	int start = document.getLineOffset(line);
	int bracketCount = getBracketCount(document, null, start, c.offset, true);
	buf.append(generateIndentation(getIndentOfLine(document, line), bracketCount <= 0 ? 0 : 1));
	c.text = buf.toString();
	} catch (BadLocationException x) {
	// ignore
	}
	}

	/**
	* Set the indent of the current line when the user hits a key. The indent will
	* either be unchanged or decremented if the user types
	*
	* @param document
	* the document being parsed
	* @param c
	* the command being performed
	*/
	protected void smartIndentAfterKeypress(IDocument document, DocumentCommand c) {
	if ((c.offset == -1) \|\| (document.getLength() == 0) \|\| c.text.trim().isEmpty()) {
	return;
	}
	try {
	StringBuilder buf = new StringBuilder();
	int p = c.offset == document.getLength() ? c.offset - 1 : c.offset;
	int line = document.getLineOfOffset(p);
	int start = document.getLineOffset(line);
	int whiteEnd = findEndOfWhiteSpace(document, start, c.offset);

	int bracketCount = getBracketCount(document, c, start, c.offset, false);
	buf.append(generateIndentation(getIndentOfLine(document, line), bracketCount >= 0 ? 0 : -1));
	buf.append(document.get(whiteEnd, c.offset - whiteEnd));
	buf.append(c.text);
	// Alter the command
	c.length = (c.offset - start) + c.length;
	c.offset = start;
	c.text = buf.toString();
	} catch (BadLocationException x) {
	// ignore
	}
	}

	/**
	* Returns the first offset greater than <code>offset</code> and smaller than
	* <code>end</code> whose character is not a space or tab character. If no such
	* offset is found, <code>end</code> is returned.
	*
	* @param document
	* the document to search in
	* @param offset
	* the offset at which searching start
	* @param end
	* the offset at which searching stops
	* @return the offset in the specified range whose character is not a space or
	* tab
	* @exception BadLocationException
	* if offset is an invalid position in the given document
	*/
	private static int findEndOfWhiteSpace(IDocument document, int offset, int end) throws BadLocationException {
	while (offset < end) {
	char c = document.getChar(offset);
	if ((c != ' ') && (c != '\t')) {
	return offset;
	}
	offset++;
	}
	return end;
	}

	/**
	* Returns the indentation of the specified line in <code>document</code>.
	*
	* @param document
	* - the document being parsed
	* @param line
	* - the line number being searched
	* @return the string containing the indentation from the specified line
	*/
	private static String getIndentOfLine(IDocument document, int line) throws BadLocationException {
	if (line > -1) {
	int start = document.getLineOffset(line);
	int end = start + document.getLineLength(line);
	int whiteend = findEndOfWhiteSpace(document, start, end);
	return document.get(start, whiteend - start);
	} else {
	return "";
	}
	}

	/**
	* Returns the bracket count of a section of text. The count is incremented when
	* an opening bracket is encountered and decremented when a closing bracket is
	* encountered.
	*
	* @param document
	* - the document being parsed
	* @param command
	* - if not null, the inserted text specified by the command will be
	* taken into account as if it were part of the document
	* @param start
	* - the start position for the search
	* @param end
	* - the end position for the search
	* @param ignoreInflexions
	* - whether or not to ignore inflexions in the count
	* @return the resulting bracket count, a positive value means we've encountered
	* more opening than closing brackets
	*/
	private int getBracketCount(IDocument document, DocumentCommand command, int start, int end,
	boolean ignoreInflexions) {
	int bracketcount = 0;
	if (command != null) {
	scanner.setRange(document, command, start, end - start);
	} else {
	scanner.setRange(document, start, end - start);
	}

	while (true) {
	IToken token = scanner.nextToken();
	if (token.isEOF()) {
	break;
	}

	if (token.isOther()) {
	IndentType type = (IndentType) token.getData();
	if (type == IndentType.INCREMENT) {
	++bracketcount;
	} else if (type == IndentType.DECREMENT) {
	--bracketcount;
	} else if ((type == IndentType.INFLEXION) && ignoreInflexions) {
	++bracketcount;
	} else if ((type == IndentType.INFLEXION) && !ignoreInflexions) {
	--bracketcount;
	}
	}
	}
	return bracketcount;
	}

	/**
	* Calculate the indentation needed for a new line based on the contents of the
	* previous line.
	*
	* @param previous
	* a string containing the indentation of the previous line
	* @param additional
	* number of desired addition indentations, may be negative
	* @return a string containing the indentation to use on the new line
	*/
	private static String generateIndentation(String previous, int additional) {
	// Get the indentation preferences
	IPreferenceStore prefs = Activator.getDefault().getPreferenceStore();
	String tabChar = prefs.getString(CodeFormatterConstants.FORMATTER_TAB_CHAR);
	int indentSize = prefs.getInt(CodeFormatterConstants.FORMATTER_INDENTATION_SIZE);
	int tabSize = prefs.getInt(CodeFormatterConstants.FORMATTER_TAB_SIZE);

	// Size in characters of the indentation of the previous line
	int preLength = computeVisualLength(previous, tabSize);

	// Number of addition characters needed
	int addLength = indentSize * additional;

	// Target size of the indentation for the new line
	int endLength = Math.max(0, preLength + addLength);

	// Trim previous indentation back to nearest tab stop
	int minLength = Math.min(endLength, preLength);
	// indent
	// to
	// copy
	String indent = stripExtraChars(previous, minLength, tabSize);

	// Add additional indentation
	int missing = endLength - minLength;
	final int tabs, spaces;
	if (CodeFormatterConstants.SPACE.equals(tabChar)) {
	// Each indent is a number of spaces equal to indent size
	tabs = 0;
	spaces = missing;
	} else if (CodeFormatterConstants.TAB.equals(tabChar)) {
	// Missing should always be in multiples of indent size, so this
	// means "one tab per indent" and indent size is essentially ignored
	tabs = missing / indentSize;
	spaces = 0;
	} else if (CodeFormatterConstants.MIXED.equals(tabChar)) {
	// If the missing indent is a multiple of tab size then tabs will be
	// used, otherwise use spaces
	tabs = tabSize > 0 ? missing / tabSize : 0;
	spaces = tabSize > 0 ? missing % tabSize : missing;
	} else {
	tabs = 0;
	spaces = 0;
	}
	for (int i = 0; i < tabs; i++) {
	indent += "\t";
	}
	for (int i = 0; i < spaces; i++) {
	indent += " ";
	}
	return indent;
	}

	/**
	* Computes the length of a an indentation, counting a tab character as the size
	* until the next tab stop and every other character as one.
	*
	* @param indent
	* the string containing the indentation to measure
	* @param tabSize
	* the visual size of tab characters
	* @return the visual length in number of characters
	*/
	private static int computeVisualLength(String indent, int tabSize) {
	int length = 0;
	for (int i = 0; i < indent.length(); i++) {
	char ch = indent.charAt(i);
	switch (ch) {
	case '\t':
	if (tabSize > 0) {
	length += tabSize;
	}
	break;
	case ' ':
	length++;
	break;
	}
	}
	return length;
	}

	/**
	* Strips any characters off the end of an indentation that exceed a specified
	* maximum visual indentation length.
	*
	* @param indent
	* the string containing the indentation to measure
	* @param max
	* the maximum visual indentation length
	* @param tabSize
	* the visual size of tab characters
	* @return a string containing the stripped indentation
	*/
	private static String stripExtraChars(String indent, int max, int tabSize) {
	int measured = 0;
	int i = 0;
	for (; (measured < max) && (i < indent.length()); i++) {
	char ch = indent.charAt(i);
	switch (ch) {
	case '\t':
	if (tabSize > 0) {
	int reminder = measured % tabSize;
	measured += tabSize - reminder;
	}
	break;
	case ' ':
	measured++;
	break;
	}
	}
	return indent.substring(0, measured > max ? i - 1 : i);
	}
	}