/*******************************************************************************
* Copyright (c) 2004, 2006s John-Mason P. Shackelford 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:
* John-Mason P. Shackelford - initial API and implementation
* IBM Corporation - bug fixes
*******************************************************************************/
package org.cfeclipse.cfml.editors.formatters;
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import org.cfeclipse.cfml.CFMLPlugin;
import org.cfeclipse.cfml.preferences.EditorPreferenceConstants;
import org.eclipse.core.runtime.Assert;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
public class XmlDocumentFormatter {
private static class CommentReader extends TagReader {
private boolean complete = false;
protected void clear() {
this.complete = false;
}
public String getStartOfTag() {
return "<!--"; //$NON-NLS-1$
}
protected String readTag() throws IOException {
int intChar;
char c;
StringBuffer node = new StringBuffer();
while (!complete && (intChar = reader.read()) != -1) {
c = (char) intChar;
node.append(c);
if (c == '>' && node.toString().endsWith("-->")) { //$NON-NLS-1$
complete = true;
}
}
return node.toString();
}
}
private static class DoctypeDeclarationReader extends TagReader {
private boolean complete = false;
protected void clear() {
this.complete = false;
}
public String getStartOfTag() {
return "<!"; //$NON-NLS-1$
}
protected String readTag() throws IOException {
int intChar;
char c;
StringBuffer node = new StringBuffer();
while (!complete && (intChar = reader.read()) != -1) {
c = (char) intChar;
node.append(c);
if (c == '>') {
complete = true;
}
}
return node.toString();
}
}
private static class ProcessingInstructionReader extends TagReader {
private boolean complete = false;
protected void clear() {
this.complete = false;
}
public String getStartOfTag() {
return "<?"; //$NON-NLS-1$
}
protected String readTag() throws IOException {
int intChar;
char c;
StringBuffer node = new StringBuffer();
while (!complete && (intChar = reader.read()) != -1) {
c = (char) intChar;
node.append(c);
if (c == '>' && node.toString().endsWith("?>")) { //$NON-NLS-1$
complete = true;
}
}
return node.toString();
}
}
private static abstract class TagReader {
protected Reader reader;
private String tagText;
protected abstract void clear();
public int getPostTagDepthModifier() {
return 0;
}
public int getPreTagDepthModifier() {
return 0;
}
abstract public String getStartOfTag();
public String getTagText() {
return this.tagText;
}
public boolean isTextNode() {
return false;
}
protected abstract String readTag() throws IOException;
public boolean requiresInitialIndent() {
return true;
}
public void setReader(Reader reader) throws IOException {
this.reader = reader;
this.clear();
this.tagText = readTag();
}
public boolean startsOnNewline() {
return true;
}
}
private static class TagReaderFactory {
// Warning: the order of the Array is important!
private static TagReader[] tagReaders = new TagReader[]{new CommentReader(),
new DoctypeDeclarationReader(),
new ProcessingInstructionReader(),
new XmlElementReader()};
private static TagReader textNodeReader = new TextReader();
public static TagReader createTagReaderFor(Reader reader)
throws IOException {
char[] buf = new char[10];
reader.mark(10);
reader.read(buf, 0, 10);
reader.reset();
String startOfTag = String.valueOf(buf);
for (int i = 0; i < tagReaders.length; i++) {
if (startOfTag.startsWith(tagReaders[i].getStartOfTag())) {
tagReaders[i].setReader(reader);
return tagReaders[i];
}
}
// else
textNodeReader.setReader(reader);
return textNodeReader;
}
}
private static class TextReader extends TagReader {
private boolean complete;
private boolean isTextNode;
protected void clear() {
this.complete = false;
}
/* (non-Javadoc)
* @see org.cfeclipse.cfml.editors.formatter.XmlDocumentFormatter.TagReader#getStartOfTag()
*/
public String getStartOfTag() {
return ""; //$NON-NLS-1$
}
/* (non-Javadoc)
* @see org.cfeclipse.cfml.editors.formatter.XmlDocumentFormatter.TagReader#isTextNode()
*/
public boolean isTextNode() {
return this.isTextNode;
}
protected String readTag() throws IOException {
StringBuffer node = new StringBuffer();
while (!complete) {
reader.mark(1);
int intChar = reader.read();
if (intChar == -1) break;
char c = (char) intChar;
if (c == '<') {
reader.reset();
complete = true;
} else {
node.append(c);
}
}
// if this text node is just whitespace
// remove it, except for the newlines.
if (node.length() < 1) {
this.isTextNode = false;
} else if (node.toString().trim().length() == 0) {
String whitespace = node.toString();
node = new StringBuffer();
for (int i = 0; i < whitespace.length(); i++) {
char whitespaceCharacter = whitespace.charAt(i);
if (whitespaceCharacter == '\n' || whitespaceCharacter == '\r') {
node.append(whitespaceCharacter);
}
}
this.isTextNode = false;
} else {
this.isTextNode = true;
}
return node.toString();
}
/* (non-Javadoc)
* @see org.cfeclipse.cfml.editors.formatter.XmlDocumentFormatter.TagReader#requiresInitialIndent()
*/
public boolean requiresInitialIndent() {
return false;
}
/* (non-Javadoc)
* @see org.cfeclipse.cfml.editors.formatter.XmlDocumentFormatter.TagReader#startsOnNewline()
*/
public boolean startsOnNewline() {
return false;
}
}
private static class XmlElementReader extends TagReader {
private boolean complete = false;
protected void clear() {
this.complete = false;
}
public int getPostTagDepthModifier() {
if (getTagText().endsWith("/>") || getTagText().endsWith("/ >")) { //$NON-NLS-1$ //$NON-NLS-2$
return 0;
} else if (getTagText().startsWith("</")) { //$NON-NLS-1$
return 0;
} else {
return +1;
}
}
public int getPreTagDepthModifier() {
if (getTagText().startsWith("</")) { //$NON-NLS-1$
return -1;
}
return 0;
}
public String getStartOfTag() {
return "<"; //$NON-NLS-1$
}
protected String readTag() throws IOException {
StringBuffer node = new StringBuffer();
boolean insideQuote = false;
int intChar;
while (!complete && (intChar = reader.read()) != -1) {
char c = (char) intChar;
node.append(c);
// TODO logic incorrectly assumes that " is quote character
// when it could also be '
if (c == '"') {
insideQuote = !insideQuote;
}
if (c == '>' && !insideQuote) {
complete = true;
}
}
return node.toString();
}
}
private int depth;
private StringBuffer formattedXml;
private boolean lastNodeWasText;
private String fDefaultLineDelimiter;
public XmlDocumentFormatter() {
super();
depth= -1;
}
private void copyNode(Reader reader, StringBuffer out, FormattingPreferences prefs) throws IOException {
TagReader tag = TagReaderFactory.createTagReaderFor(reader);
depth = depth + tag.getPreTagDepthModifier();
if (!lastNodeWasText) {
if (tag.startsOnNewline() && !hasNewlineAlready(out)) {
out.append(fDefaultLineDelimiter);
}
if (tag.requiresInitialIndent()) {
out.append(indent(prefs.getCanonicalIndent()));
}
}
out.append(tag.getTagText());
depth = depth + tag.getPostTagDepthModifier();
lastNodeWasText = tag.isTextNode();
}
/**
* Returns the indent of the given string.
*
* @param line the text line
* @param tabWidth the width of the '\t' character.
*/
public static int computeIndent(String line, int tabWidth) {
int result= 0;
int blanks= 0;
int size= line.length();
for (int i= 0; i < size; i++) {
char c= line.charAt(i);
if (c == '\t') {
result++;
blanks= 0;
} else if (isIndentChar(c)) {
blanks++;
if (blanks == tabWidth) {
result++;
blanks= 0;
}
} else {
return result;
}
}
return result;
}
/**
* Indent char is a space char but not a line delimiters.
* <code>== Character.isWhitespace(ch) && ch != '\n' && ch != '\r'</code>
*/
public static boolean isIndentChar(char ch) {
return Character.isWhitespace(ch) && !isLineDelimiterChar(ch);
}
/**
* Line delimiter chars are '\n' and '\r'.
*/
public static boolean isLineDelimiterChar(char ch) {
return ch == '\n' || ch == '\r';
}
public String format(String documentText, FormattingPreferences prefs) {
Assert.isNotNull(documentText);
Assert.isNotNull(prefs);
Reader reader = new StringReader(documentText);
formattedXml = new StringBuffer();
if (depth == -1) {
depth = 0;
}
lastNodeWasText = false;
try {
while (true) {
reader.mark(1);
int intChar = reader.read();
reader.reset();
if (intChar != -1) {
copyNode(reader, formattedXml, prefs);
} else {
break;
}
}
reader.close();
} catch (IOException e) {
e.printStackTrace();
//CFMLPlugin.log(e);
}
return formattedXml.toString();
}
private boolean hasNewlineAlready(StringBuffer out) {
return out.lastIndexOf("\n") == formattedXml.length() - 1 //$NON-NLS-1$
|| out.lastIndexOf("\r") == formattedXml.length() - 1; //$NON-NLS-1$
}
private String indent(String canonicalIndent) {
StringBuffer indent = new StringBuffer(30);
for (int i = 0; i < depth; i++) {
indent.append(canonicalIndent);
}
return indent.toString();
}
public void setInitialIndent(int indent) {
depth= indent;
}
/**
* Returns the indentation of the line at <code>offset</code> as a
* <code>StringBuffer</code>. If the offset is not valid, the empty string
* is returned.
*
* @param offset the offset in the document
* @return the indentation (leading whitespace) of the line in which
* <code>offset</code> is located
*/
public static StringBuffer getLeadingWhitespace(int offset, IDocument document) {
StringBuffer indent= new StringBuffer();
try {
IRegion line= document.getLineInformationOfOffset(offset);
int lineOffset= line.getOffset();
int nonWS= findEndOfWhiteSpace(document, lineOffset, lineOffset + line.getLength());
indent.append(document.get(lineOffset, nonWS - lineOffset));
return indent;
} catch (BadLocationException e) {
return indent;
}
}
/**
* 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 specifed range whose character is not a space or tab
* @exception BadLocationException if position is an invalid range in the given document
*/
public 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;
}
/**
* Creates a string that represents one indent (can be
* spaces or tabs..)
*
* @return one indentation
*/
public static StringBuffer createIndent() {
StringBuffer oneIndent= new StringBuffer();
IPreferenceStore pluginPrefs= CFMLPlugin.getDefault().getPreferenceStore();
if (pluginPrefs.getBoolean(EditorPreferenceConstants.P_INSERT_SPACES_FOR_TABS)) {
int tabLen= pluginPrefs.getInt(EditorPreferenceConstants.P_TAB_WIDTH);
for (int i= 0; i < tabLen; i++) {
oneIndent.append(' ');
}
} else {
oneIndent.append('\t'); // default
}
return oneIndent;
}
public void setDefaultLineDelimiter(String defaultLineDelimiter) {
fDefaultLineDelimiter= defaultLineDelimiter;
}
}