/*
* Copyright (C) 2012 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.ide.common.xml;
import com.android.SdkConstants;
import com.android.annotations.NonNull;
import com.android.annotations.Nullable;
import com.android.resources.ResourceFolderType;
import com.android.utils.SdkUtils;
import com.android.utils.XmlUtils;
import com.google.common.base.Charsets;
import com.google.common.collect.Lists;
import com.google.common.io.Files;
import org.w3c.dom.Attr;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import static com.android.SdkConstants.DOT_XML;
import static com.android.SdkConstants.TAG_COLOR;
import static com.android.SdkConstants.TAG_DIMEN;
import static com.android.SdkConstants.TAG_ITEM;
import static com.android.SdkConstants.TAG_STRING;
import static com.android.SdkConstants.TAG_STYLE;
import static com.android.SdkConstants.XMLNS;
import static com.android.utils.XmlUtils.XML_COMMENT_BEGIN;
import static com.android.utils.XmlUtils.XML_COMMENT_END;
import static com.android.utils.XmlUtils.XML_PROLOG;
/**
* Visitor which walks over the subtree of the DOM to be formatted and pretty prints
* the DOM into the given {@link StringBuilder}
*/
public class XmlPrettyPrinter {
/** The style to print the XML in */
private final XmlFormatStyle mStyle;
/** Formatting preferences to use when formatting the XML */
private final XmlFormatPreferences mPrefs;
/** Start node to start formatting at */
private Node mStartNode;
/** Start node to stop formatting after */
private Node mEndNode;
/** Whether the visitor is currently in range */
private boolean mInRange;
/** Output builder */
@SuppressWarnings("StringBufferField")
private StringBuilder mOut;
/** String to insert for a single indentation level */
private String mIndentString;
/** Line separator to use */
private String mLineSeparator;
/** If true, we're only formatting an open tag */
private boolean mOpenTagOnly;
/** List of indentation to use for each given depth */
private String[] mIndentationLevels;
/** Whether the formatter should end the document with a newline */
private boolean mEndWithNewline;
/**
* Creates a new {@link XmlPrettyPrinter}
*
* @param prefs the preferences to format with
* @param style the style to format with
* @param lineSeparator the line separator to use, such as "\n" (can be null, in which
* case the system default is looked up via the line.separator property)
*/
public XmlPrettyPrinter(XmlFormatPreferences prefs, XmlFormatStyle style,
String lineSeparator) {
mPrefs = prefs;
mStyle = style;
if (lineSeparator == null) {
lineSeparator = SdkUtils.getLineSeparator();
}
mLineSeparator = lineSeparator;
}
/**
* Sets whether the document should end with a newline/ line separator
*
* @param endWithNewline if true, ensure that the document ends with a newline
* @return this, for constructor chaining
*/
public XmlPrettyPrinter setEndWithNewline(boolean endWithNewline) {
mEndWithNewline = endWithNewline;
return this;
}
/**
* Sets the indentation levels to use (indentation string to use for each depth,
* indexed by depth
*
* @param indentationLevels an array of strings to use for the various indentation
* levels
*/
public void setIndentationLevels(String[] indentationLevels) {
mIndentationLevels = indentationLevels;
}
@NonNull
private String getLineSeparator() {
return mLineSeparator;
}
/**
* Pretty-prints the given XML document, which must be well-formed. If it is not,
* the original unformatted XML document is returned
*
* @param xml the XML content to format
* @param prefs the preferences to format with
* @param style the style to format with
* @param lineSeparator the line separator to use, such as "\n" (can be null, in which
* case the system default is looked up via the line.separator property)
* @return the formatted document (or if a parsing error occurred, returns the
* unformatted document)
*/
@NonNull
public static String prettyPrint(
@NonNull String xml,
@NonNull XmlFormatPreferences prefs,
@NonNull XmlFormatStyle style,
@Nullable String lineSeparator) {
Document document = XmlUtils.parseDocumentSilently(xml, true);
if (document != null) {
XmlPrettyPrinter printer = new XmlPrettyPrinter(prefs, style, lineSeparator);
printer.setEndWithNewline(xml.endsWith(printer.getLineSeparator()));
StringBuilder sb = new StringBuilder(3 * xml.length() / 2);
printer.prettyPrint(-1, document, null, null, sb, false /*openTagOnly*/);
return sb.toString();
} else {
// Parser error: just return the unformatted content
return xml;
}
}
/**
* Pretty prints the given node
*
* @param node the node, usually a document, to be printed
* @param prefs the formatting preferences
* @param style the formatting style to use
* @param lineSeparator the line separator to use, or null to use the
* default
* @return a formatted string
* @deprecated Use {@link #prettyPrint(org.w3c.dom.Node, XmlFormatPreferences,
* XmlFormatStyle, String, boolean)} instead
*/
@NonNull
@Deprecated
public static String prettyPrint(
@NonNull Node node,
@NonNull XmlFormatPreferences prefs,
@NonNull XmlFormatStyle style,
@Nullable String lineSeparator) {
return prettyPrint(node, prefs, style, lineSeparator, false);
}
/**
* Pretty prints the given node
*
* @param node the node, usually a document, to be printed
* @param prefs the formatting preferences
* @param style the formatting style to use
* @param lineSeparator the line separator to use, or null to use the
* default
* @param endWithNewline if true, ensure that the printed output ends with a newline
* @return a formatted string
*/
@NonNull
public static String prettyPrint(
@NonNull Node node,
@NonNull XmlFormatPreferences prefs,
@NonNull XmlFormatStyle style,
@Nullable String lineSeparator,
boolean endWithNewline) {
XmlPrettyPrinter printer = new XmlPrettyPrinter(prefs, style, lineSeparator);
printer.setEndWithNewline(endWithNewline);
StringBuilder sb = new StringBuilder(1000);
printer.prettyPrint(-1, node, null, null, sb, false /*openTagOnly*/);
String xml = sb.toString();
if (node.getNodeType() == Node.DOCUMENT_NODE && !xml.startsWith("<?")) { //$NON-NLS-1$
xml = XML_PROLOG + xml;
}
return xml;
}
/**
* Pretty prints the given node using default styles
*
* @param node the node, usually a document, to be printed
* @return the resulting formatted string
* @deprecated Use {@link #prettyPrint(org.w3c.dom.Node, boolean)} instead
*/
@NonNull
@Deprecated
public static String prettyPrint(@NonNull Node node) {
return prettyPrint(node, false);
}
/**
* Pretty prints the given node using default styles
*
* @param node the node, usually a document, to be printed
* @param endWithNewline if true, ensure that the printed output ends with a newline
* @return the resulting formatted string
*/
@NonNull
public static String prettyPrint(@NonNull Node node, boolean endWithNewline) {
return prettyPrint(node, XmlFormatPreferences.defaults(), XmlFormatStyle.get(node),
SdkUtils.getLineSeparator(), endWithNewline);
}
/**
* Start pretty-printing at the given node, which must either be the
* startNode or contain it as a descendant.
*
* @param rootDepth the depth of the given node, used to determine indentation
* @param root the node to start pretty printing from (which may not itself be
* included in the start to end node range but should contain it)
* @param startNode the node to start formatting at
* @param endNode the node to end formatting at
* @param out the {@link StringBuilder} to pretty print into
* @param openTagOnly if true, only format the open tag of the startNode (and nothing
* else)
*/
public void prettyPrint(int rootDepth, Node root, Node startNode, Node endNode,
StringBuilder out, boolean openTagOnly) {
if (startNode == null) {
startNode = root;
}
if (endNode == null) {
endNode = root;
}
assert !openTagOnly || startNode == endNode;
mStartNode = startNode;
mOpenTagOnly = openTagOnly;
mEndNode = endNode;
mOut = out;
mInRange = false;
mIndentString = mPrefs.getOneIndentUnit();
visitNode(rootDepth, root);
if (mEndWithNewline && !endsWithLineSeparator()) {
mOut.append(mLineSeparator);
}
}
/** Visit the given node at the given depth */
private void visitNode(int depth, Node node) {
if (node == mStartNode) {
mInRange = true;
}
if (mInRange) {
visitBeforeChildren(depth, node);
if (mOpenTagOnly && mStartNode == node) {
mInRange = false;
return;
}
}
NodeList children = node.getChildNodes();
for (int i = 0, n = children.getLength(); i < n; i++) {
Node child = children.item(i);
visitNode(depth + 1, child);
}
if (mInRange) {
visitAfterChildren(depth, node);
}
if (node == mEndNode) {
mInRange = false;
}
}
private void visitBeforeChildren(int depth, Node node) {
short type = node.getNodeType();
switch (type) {
case Node.DOCUMENT_NODE:
case Node.DOCUMENT_FRAGMENT_NODE:
// Nothing to do
break;
case Node.ATTRIBUTE_NODE:
// Handled as part of processing elements
break;
case Node.ELEMENT_NODE: {
printOpenElementTag(depth, node);
break;
}
case Node.TEXT_NODE: {
printText(node);
break;
}
case Node.CDATA_SECTION_NODE:
printCharacterData(node);
break;
case Node.PROCESSING_INSTRUCTION_NODE:
printProcessingInstruction(node);
break;
case Node.COMMENT_NODE: {
printComment(depth, node);
break;
}
case Node.DOCUMENT_TYPE_NODE:
printDocType(node);
break;
case Node.ENTITY_REFERENCE_NODE:
case Node.ENTITY_NODE:
case Node.NOTATION_NODE:
break;
default:
assert false : type;
}
}
private void visitAfterChildren(int depth, Node node) {
short type = node.getNodeType();
switch (type) {
case Node.ATTRIBUTE_NODE:
// Handled as part of processing elements
break;
case Node.ELEMENT_NODE: {
printCloseElementTag(depth, node);
break;
}
}
}
private void printProcessingInstruction(Node node) {
mOut.append("<?xml "); //$NON-NLS-1$
mOut.append(node.getNodeValue().trim());
mOut.append('?').append('>').append(mLineSeparator);
}
@Nullable
@SuppressWarnings("MethodMayBeStatic") // Intentionally instance method so it can be overridden
protected String getSource(@NonNull Node node) {
return null;
}
private void printDocType(Node node) {
String content = getSource(node);
if (content != null) {
mOut.append(content);
mOut.append(mLineSeparator);
}
}
private void printCharacterData(Node node) {
String nodeValue = node.getNodeValue();
boolean separateLine = nodeValue.indexOf('\n') != -1;
if (separateLine && !endsWithLineSeparator()) {
mOut.append(mLineSeparator);
}
mOut.append("<![CDATA["); //$NON-NLS-1$
mOut.append(nodeValue);
mOut.append("]]>"); //$NON-NLS-1$
if (separateLine) {
mOut.append(mLineSeparator);
}
}
private void printText(Node node) {
boolean escape = true;
String text = node.getNodeValue();
String source = getSource(node);
if (source != null) {
// Get the original source string. This will contain the actual entities
// such as ">" instead of ">" which it gets turned into for the DOM nodes.
// By operating on source we can preserve the user's entities rather than
// having > for example always turned into >.
text = source;
escape = false;
}
// Most text nodes are just whitespace for formatting (which we're replacing)
// so look for actual text content and extract that part out
String trimmed = text.trim();
if (!trimmed.isEmpty()) {
// TODO: Reformat the contents if it is too wide?
// Note that we append the actual text content, NOT the trimmed content,
// since the whitespace may be significant, e.g.
// <string name="toast_sync_error">Sync error: <xliff:g id="error">%1$s</xliff:g>...
// However, we should remove all blank lines in the prefix and suffix of the
// text node, or we will end up inserting additional blank lines each time you're
// formatting a text node within an outer element (which also adds spacing lines)
int lastPrefixNewline = -1;
for (int i = 0, n = text.length(); i < n; i++) {
char c = text.charAt(i);
if (c == '\n') {
lastPrefixNewline = i;
} else if (!Character.isWhitespace(c)) {
break;
}
}
int firstSuffixNewline = -1;
for (int i = text.length() - 1; i >= 0; i--) {
char c = text.charAt(i);
if (c == '\n') {
firstSuffixNewline = i;
} else if (!Character.isWhitespace(c)) {
break;
}
}
if (lastPrefixNewline != -1 || firstSuffixNewline != -1) {
boolean stripSuffix;
if (firstSuffixNewline == -1) {
firstSuffixNewline = text.length();
stripSuffix = false;
} else {
stripSuffix = true;
}
int stripFrom = lastPrefixNewline + 1;
if (firstSuffixNewline >= stripFrom) {
text = text.substring(stripFrom, firstSuffixNewline);
// In markup strings we may need to preserve spacing on the left and/or
// right if we're next to a markup string on the given side
if (lastPrefixNewline != -1) {
Node left = node.getPreviousSibling();
if (left != null && left.getNodeType() == Node.ELEMENT_NODE
&& isMarkupElement((Element) left)) {
text = ' ' + text;
}
}
if (stripSuffix) {
Node right = node.getNextSibling();
if (right != null && right.getNodeType() == Node.ELEMENT_NODE
&& isMarkupElement((Element) right)) {
text += ' ';
}
}
}
}
if (escape) {
XmlUtils.appendXmlTextValue(mOut, text);
} else {
// Text is already escaped
mOut.append(text);
}
if (mStyle != XmlFormatStyle.RESOURCE) {
mOut.append(mLineSeparator);
}
} else {
// Ensure that if we're in the middle of a markup string, we preserve spacing.
// In other words, "<b>first</b> <b>second</b>" - we don't want that middle
// space to disappear, but we do want repeated spaces to collapse into one.
Node left = node.getPreviousSibling();
Node right = node.getNextSibling();
if (left != null && right != null
&& left.getNodeType() == Node.ELEMENT_NODE
&& right.getNodeType() == Node.ELEMENT_NODE
&& isMarkupElement((Element)left)) {
mOut.append(' ');
}
}
}
private void printComment(int depth, Node node) {
String comment = node.getNodeValue();
boolean multiLine = comment.indexOf('\n') != -1;
String trimmed = comment.trim();
// See if this is an "end-of-the-line" comment, e.g. it is not a multi-line
// comment and it appears on the same line as an opening or closing element tag;
// if so, continue to place it as a suffix comment
boolean isSuffixComment = false;
if (!multiLine) {
Node previous = node.getPreviousSibling();
isSuffixComment = true;
if (previous == null && node.getParentNode().getNodeType() == Node.DOCUMENT_NODE) {
isSuffixComment = false;
}
while (previous != null) {
short type = previous.getNodeType();
if (type == Node.COMMENT_NODE) {
isSuffixComment = false;
break;
} else if (type == Node.TEXT_NODE) {
if (previous.getNodeValue().indexOf('\n') != -1) {
isSuffixComment = false;
break;
}
} else {
break;
}
previous = previous.getPreviousSibling();
}
if (isSuffixComment) {
// Remove newline added by element open tag or element close tag
if (endsWithLineSeparator()) {
removeLastLineSeparator();
}
mOut.append(' ');
}
}
// Put the comment on a line on its own? Only if it was separated by a blank line
// in the previous version of the document. In other words, if the document
// adds blank lines between comments this formatter will preserve that fact, and vice
// versa for a tightly formatted document it will preserve that convention as well.
if (!mPrefs.removeEmptyLines && !isSuffixComment) {
Node curr = node.getPreviousSibling();
if (curr == null) {
if (mOut.length() > 0 && !endsWithLineSeparator()) {
mOut.append(mLineSeparator);
}
} else if (curr.getNodeType() == Node.TEXT_NODE) {
String text = curr.getNodeValue();
// Count how many newlines we find in the trailing whitespace of the
// text node
int newLines = 0;
for (int i = text.length() - 1; i >= 0; i--) {
char c = text.charAt(i);
if (Character.isWhitespace(c)) {
if (c == '\n') {
newLines++;
if (newLines == 2) {
break;
}
}
} else {
break;
}
}
if (newLines >= 2) {
mOut.append(mLineSeparator);
} else if (text.trim().isEmpty() && curr.getPreviousSibling() == null) {
// Comment before first child in node
mOut.append(mLineSeparator);
}
}
}
// TODO: Reformat the comment text?
if (!multiLine) {
if (!isSuffixComment) {
indent(depth);
}
mOut.append(XML_COMMENT_BEGIN).append(' ');
mOut.append(trimmed);
mOut.append(' ').append(XML_COMMENT_END);
mOut.append(mLineSeparator);
} else {
// Strip off blank lines at the beginning and end of the comment text.
// Find last newline at the beginning of the text:
int index = 0;
int end = comment.length();
int recentNewline = -1;
while (index < end) {
char c = comment.charAt(index);
if (c == '\n') {
recentNewline = index;
}
if (!Character.isWhitespace(c)) {
break;
}
index++;
}
int start = recentNewline + 1;
// Find last newline at the end of the text
index = end - 1;
recentNewline = -1;
while (index > start) {
char c = comment.charAt(index);
if (c == '\n') {
recentNewline = index;
}
if (!Character.isWhitespace(c)) {
break;
}
index--;
}
end = recentNewline == -1 ? index + 1 : recentNewline;
if (start >= end) {
// It's a blank comment like <!-- \n\n--> - just clean it up
if (!isSuffixComment) {
indent(depth);
}
mOut.append(XML_COMMENT_BEGIN).append(' ').append(XML_COMMENT_END);
mOut.append(mLineSeparator);
return;
}
trimmed = comment.substring(start, end);
// When stripping out prefix and suffix blank lines we might have ended up
// with a single line comment again so check and format single line comments
// without newlines inside the <!-- --> delimiters
multiLine = trimmed.indexOf('\n') != -1;
if (multiLine) {
indent(depth);
mOut.append(XML_COMMENT_BEGIN);
mOut.append(mLineSeparator);
// See if we need to add extra spacing to keep alignment. Consider a comment
// like this:
// <!-- Deprecated strings - Move the identifiers to this section,
// and remove the actual text. -->
// This String will be
// " Deprecated strings - Move the identifiers to this section,\n" +
// " and remove the actual text. -->"
// where the left side column no longer lines up.
// To fix this, we need to insert some extra whitespace into the first line
// of the string; in particular, the exact number of characters that the
// first line of the comment was indented with!
// However, if the comment started like this:
// <!--
// /** Copyright
// -->
// then obviously the align-indent is 0, so we only want to compute an
// align indent when we don't find a newline before the content
boolean startsWithNewline = false;
for (int i = 0; i < start; i++) {
if (comment.charAt(i) == '\n') {
startsWithNewline = true;
break;
}
}
if (!startsWithNewline) {
Node previous = node.getPreviousSibling();
if (previous != null && previous.getNodeType() == Node.TEXT_NODE) {
String prevText = previous.getNodeValue();
int indentation = XML_COMMENT_BEGIN.length();
for (int i = prevText.length() - 1; i >= 0; i--) {
char c = prevText.charAt(i);
if (c == '\n') {
break;
} else {
indentation += (c == '\t') ? mPrefs.getTabWidth() : 1;
}
}
// See if the next line after the newline has indentation; if it doesn't,
// leave things alone. This fixes a case like this:
// <!-- This is the
// comment block -->
// such that it doesn't turn it into
// <!--
// This is the
// comment block
// -->
// In this case we instead want
// <!--
// This is the
// comment block
// -->
int minIndent = Integer.MAX_VALUE;
String[] lines = trimmed.split("\n"); //$NON-NLS-1$
// Skip line 0 since we know that it doesn't start with a newline
for (int i = 1; i < lines.length; i++) {
int indent = 0;
String line = lines[i];
for (int j = 0; j < line.length(); j++) {
char c = line.charAt(j);
if (!Character.isWhitespace(c)) {
// Only set minIndent if there's text content on the line;
// blank lines can exist in the comment without affecting
// the overall minimum indentation boundary.
if (indent < minIndent) {
minIndent = indent;
}
break;
} else {
indent += (c == '\t') ? mPrefs.getTabWidth() : 1;
}
}
}
if (minIndent < indentation) {
indentation = minIndent;
// Subtract any indentation that is already present on the line
String line = lines[0];
for (int j = 0; j < line.length(); j++) {
char c = line.charAt(j);
if (!Character.isWhitespace(c)) {
break;
} else {
indentation -= (c == '\t') ? mPrefs.getTabWidth() : 1;
}
}
}
for (int i = 0; i < indentation; i++) {
mOut.append(' ');
}
if (indentation < 0) {
boolean prefixIsSpace = true;
for (int i = 0; i < -indentation && i < trimmed.length(); i++) {
if (!Character.isWhitespace(trimmed.charAt(i))) {
prefixIsSpace = false;
break;
}
}
if (prefixIsSpace) {
trimmed = trimmed.substring(-indentation);
}
}
}
}
mOut.append(trimmed);
mOut.append(mLineSeparator);
indent(depth);
mOut.append(XML_COMMENT_END);
mOut.append(mLineSeparator);
} else {
mOut.append(XML_COMMENT_BEGIN).append(' ');
mOut.append(trimmed);
mOut.append(' ').append(XML_COMMENT_END);
mOut.append(mLineSeparator);
}
}
// Preserve whitespace after comment: See if the original document had two or
// more newlines after the comment, and if so have a blank line between this
// comment and the next
Node next = node.getNextSibling();
if (!mPrefs.removeEmptyLines && (next != null)
&& (next.getNodeType() == Node.TEXT_NODE)) {
String text = next.getNodeValue();
int newLinesBeforeText = 0;
for (int i = 0, n = text.length(); i < n; i++) {
char c = text.charAt(i);
if (c == '\n') {
newLinesBeforeText++;
if (newLinesBeforeText == 2) {
// Yes
mOut.append(mLineSeparator);
break;
}
} else if (!Character.isWhitespace(c)) {
break;
}
}
}
}
private boolean endsWithLineSeparator() {
int separatorLength = mLineSeparator.length();
if (mOut.length() >= separatorLength) {
for (int i = 0, j = mOut.length() - separatorLength; i < separatorLength; i++) {
if (mOut.charAt(j) != mLineSeparator.charAt(i)) {
return false;
}
}
}
return true;
}
private void removeLastLineSeparator() {
int newLength = mOut.length() - mLineSeparator.length();
if (newLength >= 0) {
mOut.setLength(newLength);
}
}
private void printOpenElementTag(int depth, Node node) {
Element element = (Element) node;
if (newlineBeforeElementOpen(element, depth)) {
mOut.append(mLineSeparator);
}
if (indentBeforeElementOpen(element, depth)) {
indent(depth);
}
mOut.append('<').append(element.getTagName());
NamedNodeMap attributes = element.getAttributes();
int attributeCount = attributes.getLength();
if (attributeCount > 0) {
// Sort the attributes
List<Attr> attributeList = new ArrayList<Attr>();
for (int i = 0; i < attributeCount; i++) {
attributeList.add((Attr) attributes.item(i));
}
Comparator<Attr> comparator = mPrefs.getAttributeComparator();
if (comparator != null) {
Collections.sort(attributeList, comparator);
}
// Put the single attribute on the same line as the element tag?
boolean singleLine = mPrefs.oneAttributeOnFirstLine && attributeCount == 1
// In resource files we always put all the attributes (which is
// usually just zero, one or two) on the same line
|| mStyle == XmlFormatStyle.RESOURCE;
// We also place the namespace declaration on the same line as the root element,
// but this doesn't also imply singleLine handling; subsequent attributes end up
// on their own lines
boolean indentNextAttribute;
if (singleLine || (depth == 0 && XMLNS.equals(attributeList.get(0).getPrefix()))) {
mOut.append(' ');
indentNextAttribute = false;
} else {
mOut.append(mLineSeparator);
indentNextAttribute = true;
}
Attr last = attributeList.get(attributeCount - 1);
for (Attr attribute : attributeList) {
if (indentNextAttribute) {
indent(depth + 1);
}
mOut.append(attribute.getName());
mOut.append('=').append('"');
XmlUtils.appendXmlAttributeValue(mOut, attribute.getValue());
mOut.append('"');
// Don't add a newline at the last attribute line; the > should
// immediately follow the last attribute
if (attribute != last) {
mOut.append(singleLine ? " " : mLineSeparator); //$NON-NLS-1$
indentNextAttribute = !singleLine;
}
}
}
boolean isClosed = isEmptyTag(element);
// Add a space before the > or /> ? In resource files, only do this when closing the
// element
if (mPrefs.spaceBeforeClose && (mStyle != XmlFormatStyle.RESOURCE || isClosed)
// in <selector> files etc still treat the <item> entries as in resource files
&& !TAG_ITEM.equals(element.getTagName())
&& (isClosed || element.getAttributes().getLength() > 0)) {
mOut.append(' ');
}
if (isClosed) {
mOut.append('/');
}
mOut.append('>');
if (newlineAfterElementOpen(element, depth, isClosed)) {
mOut.append(mLineSeparator);
}
}
private void printCloseElementTag(int depth, Node node) {
Element element = (Element) node;
if (isEmptyTag(element)) {
// Empty tag: Already handled as part of opening tag
return;
}
// Put the closing declaration on its own line - unless it's a compact
// resource file format
// If the element had element children, separate the end tag from them
if (newlineBeforeElementClose(element, depth)) {
mOut.append(mLineSeparator);
}
if (indentBeforeElementClose(element, depth)) {
indent(depth);
}
mOut.append('<').append('/');
mOut.append(node.getNodeName());
mOut.append('>');
if (newlineAfterElementClose(element, depth)) {
mOut.append(mLineSeparator);
}
}
private boolean newlineBeforeElementOpen(Element element, int depth) {
if (hasBlankLineAbove()) {
return false;
}
if (mPrefs.removeEmptyLines || depth <= 0) {
return false;
}
if (isMarkupElement(element)) {
return false;
}
// See if this element should be separated from the previous element.
// This is the case if we are not compressing whitespace (checked above),
// or if we are not immediately following a comment (in which case the
// newline would have been added above it), or if we are not in a formatting
// style where
if (mStyle == XmlFormatStyle.LAYOUT) {
// In layouts we always separate elements
return true;
}
if (mStyle == XmlFormatStyle.MANIFEST || mStyle == XmlFormatStyle.RESOURCE
|| mStyle == XmlFormatStyle.FILE) {
Node curr = element.getPreviousSibling();
// <style> elements are traditionally separated unless it follows a comment
if (TAG_STYLE.equals(element.getTagName())) {
if (curr == null
|| curr.getNodeType() == Node.ELEMENT_NODE
|| (curr.getNodeType() == Node.TEXT_NODE
&& curr.getNodeValue().trim().isEmpty()
&& (curr.getPreviousSibling() == null
|| curr.getPreviousSibling().getNodeType()
== Node.ELEMENT_NODE))) {
return true;
}
}
// In all other styles, we separate elements if they have a different tag than
// the previous one (but we don't insert a newline inside tags)
while (curr != null) {
short nodeType = curr.getNodeType();
if (nodeType == Node.ELEMENT_NODE) {
Element sibling = (Element) curr;
if (!element.getTagName().equals(sibling.getTagName())) {
return true;
}
break;
} else if (nodeType == Node.TEXT_NODE) {
String text = curr.getNodeValue();
if (!text.trim().isEmpty()) {
break;
}
// If there is just whitespace, continue looking for a previous sibling
} else {
// Any other previous node type, such as a comment, means we don't
// continue looking: this element should not be separated
break;
}
curr = curr.getPreviousSibling();
}
if (curr == null && depth <= 1) {
// Insert new line inside tag if it's the first element inside the root tag
return true;
}
return false;
}
return false;
}
private boolean indentBeforeElementOpen(Element element, int depth) {
if (isMarkupElement(element)) {
return false;
}
if (element.getParentNode().getNodeType() == Node.ELEMENT_NODE
&& keepElementAsSingleLine(depth - 1, (Element) element.getParentNode())) {
return false;
}
return true;
}
private boolean indentBeforeElementClose(Element element, int depth) {
if (isMarkupElement(element)) {
return false;
}
char lastOutChar = mOut.charAt(mOut.length() - 1);
char lastDelimiterChar = mLineSeparator.charAt(mLineSeparator.length() - 1);
return lastOutChar == lastDelimiterChar;
}
private boolean newlineAfterElementOpen(Element element, int depth, boolean isClosed) {
if (hasBlankLineAbove()) {
return false;
}
if (isMarkupElement(element)) {
return false;
}
// In resource files we keep the child content directly on the same
// line as the element (unless it has children). in other files, separate them
return isClosed || !keepElementAsSingleLine(depth, element);
}
private boolean newlineBeforeElementClose(Element element, int depth) {
if (hasBlankLineAbove()) {
return false;
}
if (isMarkupElement(element)) {
return false;
}
return depth == 0 && !mPrefs.removeEmptyLines;
}
private boolean hasBlankLineAbove() {
if (mOut.length() < 2 * mLineSeparator.length()) {
return false;
}
return SdkUtils.endsWith(mOut, mLineSeparator) &&
SdkUtils.endsWith(mOut, mOut.length() - mLineSeparator.length(), mLineSeparator);
}
private boolean newlineAfterElementClose(Element element, int depth) {
if (hasBlankLineAbove()) {
return false;
}
if (isMarkupElement(element)) {
return false;
}
return element.getParentNode().getNodeType() == Node.ELEMENT_NODE
&& !keepElementAsSingleLine(depth - 1, (Element) element.getParentNode());
}
private boolean isMarkupElement(Element element) {
// The documentation suggests that the allowed tags are <u>, <b> and <i>:
// developer.android.com/guide/topics/resources/string-resource.html#FormattingAndStyling
// However, the full set of tags accepted by Html.fromHtml is much larger. Therefore,
// instead consider *any* element nested inside a <string> definition to be a markup
// element. See frameworks/base/core/java/android/text/Html.java and look for
// HtmlToSpannedConverter#handleStartTag.
if (mStyle != XmlFormatStyle.RESOURCE) {
return false;
}
Node curr = element.getParentNode();
while (curr != null) {
if (TAG_STRING.equals(curr.getNodeName())) {
return true;
}
curr = curr.getParentNode();
}
return false;
}
/**
* TODO: Explain why we need to do per-tag decisions on whether to keep them on the
* same line or not. Show that we can't just do it by depth, or by file type.
* (style versus plurals example)
* @param element the element whose tag we want to check
* @return true if the element is a single line tag
*/
private boolean isSingleLineTag(Element element) {
String tag = element.getTagName();
return (tag.equals(TAG_ITEM) && mStyle == XmlFormatStyle.RESOURCE)
|| tag.equals(TAG_STRING)
|| tag.equals(TAG_DIMEN)
|| tag.equals(TAG_COLOR);
}
private boolean keepElementAsSingleLine(int depth, Element element) {
if (depth == 0) {
return false;
}
return isSingleLineTag(element)
|| (mStyle == XmlFormatStyle.RESOURCE
&& !XmlUtils.hasElementChildren(element));
}
private void indent(int depth) {
int i = 0;
if (mIndentationLevels != null) {
for (int j = Math.min(depth, mIndentationLevels.length - 1); j >= 0; j--) {
String indent = mIndentationLevels[j];
if (indent != null) {
mOut.append(indent);
i = j;
break;
}
}
}
for (; i < depth; i++) {
mOut.append(mIndentString);
}
}
/**
* Returns true if the given element should be an empty tag
*
* @param element the element to test
* @return true if this element should be an empty tag
*/
@SuppressWarnings("MethodMayBeStatic") // Intentionally instance method so it can be overridden
protected boolean isEmptyTag(Element element) {
if (element.getFirstChild() != null) {
return false;
}
String tag = element.getTagName();
if (TAG_STRING.equals(tag)) {
return false;
}
return true;
}
private static void printUsage() {
System.out.println("Usage: " + XmlPrettyPrinter.class.getSimpleName() +
" <options>... <files or directories...>");
System.out.println("OPTIONS:");
System.out.println("--stdout");
System.out.println("--removeEmptyLines");
System.out.println("--noAttributeOnFirstLine");
System.out.println("--noSpaceBeforeClose");
System.exit(1);
}
/** Command line driver */
public static void main(String[] args) {
if (args.length == 0) {
printUsage();
}
List<File> files = Lists.newArrayList();
XmlFormatPreferences prefs = XmlFormatPreferences.defaults();
boolean stdout = false;
for (String arg : args) {
if (arg.startsWith("--")) {
if ("--stdout".equals(arg)) {
stdout = true;
} else if ("--removeEmptyLines".equals(arg)) {
prefs.removeEmptyLines = true;
} else if ("--noAttributeOnFirstLine".equals(arg)) {
prefs.oneAttributeOnFirstLine = false;
} else if ("--noSpaceBeforeClose".equals(arg)) {
prefs.spaceBeforeClose = false;
} else {
System.err.println("Unknown flag " + arg);
printUsage();
}
} else {
File file = new File(arg).getAbsoluteFile();
if (!file.exists()) {
System.err.println("Can't find file " + file);
System.exit(1);
} else {
files.add(file);
}
}
}
for (File file : files) {
formatFile(prefs, file, stdout);
}
System.exit(0);
}
private static void formatFile(@NonNull XmlFormatPreferences prefs, File file,
boolean stdout) {
if (file.isDirectory()) {
File[] files = file.listFiles();
if (files != null) {
for (File child : files) {
formatFile(prefs, child, stdout);
}
}
} else if (file.isFile() && SdkUtils.endsWithIgnoreCase(file.getName(), DOT_XML)) {
XmlFormatStyle style = null;
if (file.getName().equals(SdkConstants.ANDROID_MANIFEST_XML)) {
style = XmlFormatStyle.MANIFEST;
} else {
File parent = file.getParentFile();
if (parent != null) {
String parentName = parent.getName();
ResourceFolderType folderType = ResourceFolderType.getFolderType(parentName);
if (folderType == ResourceFolderType.LAYOUT) {
style = XmlFormatStyle.LAYOUT;
} else if (folderType == ResourceFolderType.VALUES) {
style = XmlFormatStyle.RESOURCE;
}
}
}
try {
String xml = Files.toString(file, Charsets.UTF_8);
Document document = XmlUtils.parseDocumentSilently(xml, true);
if (document == null) {
System.err.println("Could not parse " + file);
System.exit(1);
return;
}
if (style == null) {
style = XmlFormatStyle.get(document);
}
boolean endWithNewline = xml.endsWith("\n");
int firstNewLine = xml.indexOf('\n');
String lineSeparator = firstNewLine > 0 && xml.charAt(firstNewLine - 1) == '\r' ?
"\r\n" : "\n";
String formatted = XmlPrettyPrinter.prettyPrint(document, prefs, style,
lineSeparator, endWithNewline);
if (stdout) {
System.out.println(formatted);
} else {
Files.write(formatted, file, Charsets.UTF_8);
}
} catch (IOException e) {
System.err.println("Could not read " + file);
System.exit(1);
}
}
}
}