| /* |
| * Copyright (C) 2011 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.manifmerger; |
| |
| import com.android.annotations.NonNull; |
| import com.android.annotations.Nullable; |
| import com.android.annotations.VisibleForTesting; |
| import com.android.manifmerger.IMergerLog.FileAndLine; |
| import com.android.manifmerger.IMergerLog.Severity; |
| import com.android.utils.ILogger; |
| import com.android.utils.XmlUtils; |
| |
| 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.xml.sax.ErrorHandler; |
| import org.xml.sax.InputSource; |
| import org.xml.sax.SAXParseException; |
| |
| import java.io.File; |
| import java.io.FileNotFoundException; |
| import java.io.Reader; |
| import java.io.StringWriter; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| |
| import javax.xml.parsers.DocumentBuilder; |
| import javax.xml.parsers.DocumentBuilderFactory; |
| import javax.xml.transform.OutputKeys; |
| import javax.xml.transform.Transformer; |
| import javax.xml.transform.TransformerException; |
| import javax.xml.transform.TransformerFactory; |
| import javax.xml.transform.dom.DOMSource; |
| import javax.xml.transform.stream.StreamResult; |
| |
| /** |
| * A few XML handling utilities. |
| */ |
| class MergerXmlUtils { |
| |
| private static final String DATA_ORIGIN_FILE = "manif.merger.file"; //$NON-NLS-1$ |
| private static final String DATA_FILE_NAME = "manif.merger.filename"; //$NON-NLS-1$ |
| private static final String DATA_LINE_NUMBER = "manif.merger.line#"; //$NON-NLS-1$ |
| |
| /** |
| * Parses the given XML file as a DOM document. |
| * The parser does not validate the DTD nor any kind of schema. |
| * It is namespace aware. |
| * <p/> |
| * This adds a user tag with the original {@link File} to the returned document. |
| * You can retrieve this file later by using {@link #extractXmlFilename(Node)}. |
| * |
| * @param xmlFile The XML {@link File} to parse. Must not be null. |
| * @param log An {@link ILogger} for reporting errors. Must not be null. |
| * @param merger The {@link ManifestMerger} this document is intended for |
| * @return A new DOM {@link Document}, or null. |
| */ |
| @Nullable |
| static Document parseDocument(@NonNull final File xmlFile, @NonNull final IMergerLog log, |
| @NonNull ManifestMerger merger) { |
| try { |
| DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); |
| Reader reader = XmlUtils.getUtfReader(xmlFile); |
| InputSource is = new InputSource(reader); |
| factory.setNamespaceAware(true); |
| factory.setValidating(false); |
| DocumentBuilder builder = factory.newDocumentBuilder(); |
| |
| // We don't want the default handler which prints errors to stderr. |
| builder.setErrorHandler(new ErrorHandler() { |
| @Override |
| public void warning(SAXParseException e) { |
| log.error(Severity.WARNING, |
| new FileAndLine(xmlFile.getAbsolutePath(), 0), |
| "Warning when parsing: %1$s", |
| e.toString()); |
| } |
| @Override |
| public void fatalError(SAXParseException e) { |
| log.error(Severity.ERROR, |
| new FileAndLine(xmlFile.getAbsolutePath(), 0), |
| "Fatal error when parsing: %1$s", |
| xmlFile.getName(), e.toString()); |
| } |
| @Override |
| public void error(SAXParseException e) { |
| log.error(Severity.ERROR, |
| new FileAndLine(xmlFile.getAbsolutePath(), 0), |
| "Error when parsing: %1$s", |
| e.toString()); |
| } |
| }); |
| |
| Document doc = builder.parse(is); |
| doc.setUserData(DATA_ORIGIN_FILE, xmlFile, null /*handler*/); |
| findLineNumbers(doc, 1); |
| |
| if (merger.isInsertSourceMarkers()) { |
| setSource(doc, xmlFile); |
| } |
| |
| return doc; |
| |
| } catch (FileNotFoundException e) { |
| log.error(Severity.ERROR, |
| new FileAndLine(xmlFile.getAbsolutePath(), 0), |
| "XML file not found"); |
| |
| } catch (Exception e) { |
| log.error(Severity.ERROR, |
| new FileAndLine(xmlFile.getAbsolutePath(), 0), |
| "Failed to parse XML file: %1$s", |
| e.toString()); |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Parses the given XML string as a DOM document. |
| * The parser does not validate the DTD nor any kind of schema. |
| * It is namespace aware. |
| * |
| * @param xml The XML string to parse. Must not be null. |
| * @param log An {@link ILogger} for reporting errors. Must not be null. |
| * @return A new DOM {@link Document}, or null. |
| */ |
| @VisibleForTesting |
| @Nullable |
| static Document parseDocument(@NonNull String xml, |
| @NonNull IMergerLog log, |
| @NonNull FileAndLine errorContext) { |
| try { |
| Document doc = XmlUtils.parseDocument(xml, true); |
| findLineNumbers(doc, 1); |
| if (errorContext.getFileName() != null) { |
| setSource(doc, new File(errorContext.getFileName())); |
| } |
| return doc; |
| } catch (Exception e) { |
| log.error(Severity.ERROR, errorContext, "Failed to parse XML string"); |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Decorates the document with the specified file name, which can be |
| * retrieved later by calling {@link #extractLineNumber(Node)}. |
| * <p/> |
| * It also tries to add line number information, with the caveat that the |
| * current implementation is a gross approximation. |
| * <p/> |
| * There is no need to call this after calling one of the {@code parseDocument()} |
| * methods since they already decorated their own document. |
| * |
| * @param doc The document to decorate. |
| * @param fileName The name to retrieve later for that document. |
| */ |
| static void decorateDocument(@NonNull Document doc, @NonNull String fileName) { |
| doc.setUserData(DATA_FILE_NAME, fileName, null /*handler*/); |
| findLineNumbers(doc, 1); |
| } |
| |
| /** |
| * Returns a new {@link FileAndLine} structure that identifies |
| * the base filename & line number from which the XML node was parsed. |
| * <p/> |
| * When the line number is unknown (e.g. if a {@link Document} instance is given) |
| * then line number 0 will be used. |
| * |
| * @param node The node or document where the error occurs. Must not be null. |
| * @return A new non-null {@link FileAndLine} combining the file name and line number. |
| */ |
| @NonNull |
| static FileAndLine xmlFileAndLine(@NonNull Node node) { |
| String name = extractXmlFilename(node); |
| int line = extractLineNumber(node); // 0 in case of error or unknown |
| return new FileAndLine(name, line); |
| } |
| |
| /** |
| * Extracts the origin {@link File} that {@link #parseDocument(File, IMergerLog, |
| * ManifestMerger)} added to the XML document or the string added by |
| * |
| * @param xmlNode Any node from a document returned by {@link #parseDocument(File, IMergerLog, |
| * ManifestMerger)}. |
| * @return The {@link File} object used to create the document or null. |
| */ |
| @Nullable |
| static String extractXmlFilename(@Nullable Node xmlNode) { |
| if (xmlNode != null && xmlNode.getNodeType() != Node.DOCUMENT_NODE) { |
| xmlNode = xmlNode.getOwnerDocument(); |
| } |
| if (xmlNode != null) { |
| Object data = xmlNode.getUserData(DATA_ORIGIN_FILE); |
| if (data instanceof File) { |
| return ((File) data).getPath(); |
| } |
| data = xmlNode.getUserData(DATA_FILE_NAME); |
| if (data instanceof String) { |
| return (String) data; |
| } |
| } |
| |
| return null; |
| } |
| |
| public static void setSource(@NonNull Node node, @NonNull File source) { |
| //noinspection ConstantConditions |
| for (; node != null; node = node.getNextSibling()) { |
| short nodeType = node.getNodeType(); |
| if (nodeType == Node.ELEMENT_NODE |
| || nodeType == Node.COMMENT_NODE |
| || nodeType == Node.DOCUMENT_NODE |
| || nodeType == Node.CDATA_SECTION_NODE) { |
| node.setUserData(DATA_ORIGIN_FILE, source, null); |
| } |
| Node child = node.getFirstChild(); |
| setSource(child, source); |
| } |
| } |
| |
| /** |
| * This is a CRUDE INEXACT HACK to decorate the DOM with some kind of line number |
| * information for elements. It's inexact because by the time we get the DOM we |
| * already have lost all the information about whitespace between attributes. |
| * <p/> |
| * Also we don't even try to deal with \n vs \r vs \r\n insanity. This only counts |
| * the \n occurring in text nodes to determine line advances, which is clearly flawed. |
| * <p/> |
| * However it's good enough for testing, and we'll replace it by a PositionXmlParser |
| * once it's moved into com.android.util. |
| */ |
| private static int findLineNumbers(Node node, int line) { |
| for (; node != null; node = node.getNextSibling()) { |
| node.setUserData(DATA_LINE_NUMBER, Integer.valueOf(line), null /*handler*/); |
| |
| if (node.getNodeType() == Node.TEXT_NODE) { |
| String text = node.getNodeValue(); |
| if (!text.isEmpty()) { |
| for (int pos = 0; (pos = text.indexOf('\n', pos)) != -1; pos++) { |
| ++line; |
| } |
| } |
| } |
| |
| Node child = node.getFirstChild(); |
| if (child != null) { |
| line = findLineNumbers(child, line); |
| } |
| } |
| return line; |
| } |
| |
| /** |
| * Extracts the line number that {@link #findLineNumbers} added to the XML nodes. |
| * |
| * @param xmlNode Any node from a document returned by {@link #parseDocument(File, IMergerLog, |
| * ManifestMerger)}. |
| * @return The line number if found or 0. |
| */ |
| static int extractLineNumber(@Nullable Node xmlNode) { |
| if (xmlNode != null) { |
| Object data = xmlNode.getUserData(DATA_LINE_NUMBER); |
| if (data instanceof Integer) { |
| return ((Integer) data).intValue(); |
| } |
| } |
| |
| return 0; |
| } |
| |
| /** |
| * Outputs the given XML {@link Document} to the file {@code outFile}. |
| * |
| * TODO right now reformats the document. Needs to output as-is, respecting white-space. |
| * |
| * @param doc The document to output. Must not be null. |
| * @param outFile The {@link File} where to write the document. |
| * @param log A log in case of error. |
| * @return True if the file was written, false in case of error. |
| */ |
| static boolean printXmlFile( |
| @NonNull Document doc, |
| @NonNull File outFile, |
| @NonNull IMergerLog log) { |
| // Quick thing based on comments from http://stackoverflow.com/questions/139076 |
| try { |
| Transformer tf = TransformerFactory.newInstance().newTransformer(); |
| tf.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes"); //$NON-NLS-1$ |
| tf.setOutputProperty(OutputKeys.ENCODING, "UTF-8"); //$NON-NLS-1$ |
| tf.setOutputProperty(OutputKeys.INDENT, "yes"); //$NON-NLS-1$ |
| tf.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", //$NON-NLS-1$ |
| "4"); //$NON-NLS-1$ |
| tf.transform(new DOMSource(doc), new StreamResult(outFile)); |
| return true; |
| } catch (TransformerException e) { |
| log.error(Severity.ERROR, |
| new FileAndLine(outFile.getName(), 0), |
| "Failed to write XML file: %1$s", |
| e.toString()); |
| return false; |
| } |
| } |
| |
| /** |
| * Outputs the given XML {@link Document} as a string. |
| * |
| * TODO right now reformats the document. Needs to output as-is, respecting white-space. |
| * |
| * @param doc The document to output. Must not be null. |
| * @param log A log in case of error. |
| * @return A string representation of the XML. Null in case of error. |
| */ |
| static String printXmlString( |
| @NonNull Document doc, |
| @NonNull IMergerLog log) { |
| try { |
| Transformer tf = TransformerFactory.newInstance().newTransformer(); |
| tf.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes"); //$NON-NLS-1$ |
| tf.setOutputProperty(OutputKeys.ENCODING, "UTF-8"); //$NON-NLS-1$ |
| tf.setOutputProperty(OutputKeys.INDENT, "yes"); //$NON-NLS-1$ |
| tf.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", //$NON-NLS-1$ |
| "4"); //$NON-NLS-1$ |
| StringWriter sw = new StringWriter(); |
| tf.transform(new DOMSource(doc), new StreamResult(sw)); |
| return sw.toString(); |
| } catch (TransformerException e) { |
| log.error(Severity.ERROR, |
| new FileAndLine(extractXmlFilename(doc), 0), |
| "Failed to write XML file: %1$s", |
| e.toString()); |
| return null; |
| } |
| } |
| |
| /** |
| * Dumps the structure of the DOM to a simple text string. |
| * |
| * @param node The first node to dump (recursively). Can be null. |
| * @param nextSiblings If true, will also dump the following siblings. |
| * If false, it will just process the given node. |
| * @return A string representation of the Node structure, useful for debugging. |
| */ |
| @NonNull |
| static String dump(@Nullable Node node, boolean nextSiblings) { |
| return dump(node, 0 /*offset*/, nextSiblings, true /*deep*/, null /*keyAttr*/); |
| } |
| |
| |
| /** |
| * Dumps the structure of the DOM to a simple text string. |
| * Each line is terminated with a \n separator. |
| * |
| * @param node The first node to dump. Can be null. |
| * @param offsetIndex The offset to add at the begining of each line. Each offset is |
| * converted into 2 space characters. |
| * @param nextSiblings If true, will also dump the following siblings. |
| * If false, it will just process the given node. |
| * @param deep If true, this will recurse into children. |
| * @param keyAttr An optional attribute *local* name to insert when writing an element. |
| * For example when writing an Activity, it helps to always insert "name" attribute. |
| * @return A string representation of the Node structure, useful for debugging. |
| */ |
| @NonNull |
| static String dump( |
| @Nullable Node node, |
| int offsetIndex, |
| boolean nextSiblings, |
| boolean deep, |
| @Nullable String keyAttr) { |
| StringBuilder sb = new StringBuilder(); |
| |
| String offset = ""; //$NON-NLS-1$ |
| for (int i = 0; i < offsetIndex; i++) { |
| offset += " "; //$NON-NLS-1$ |
| } |
| |
| if (node == null) { |
| sb.append(offset).append("(end reached)\n"); |
| |
| } else { |
| for (; node != null; node = node.getNextSibling()) { |
| String type = null; |
| short t = node.getNodeType(); |
| switch(t) { |
| case Node.ELEMENT_NODE: |
| String attr = ""; |
| if (keyAttr != null) { |
| for (Node a : sortedAttributeList(node.getAttributes())) { |
| if (a != null && keyAttr.equals(a.getLocalName())) { |
| attr = String.format(" %1$s=%2$s", |
| a.getNodeName(), a.getNodeValue()); |
| break; |
| } |
| } |
| } |
| sb.append(String.format("%1$s<%2$s%3$s>\n", |
| offset, node.getNodeName(), attr)); |
| break; |
| case Node.COMMENT_NODE: |
| sb.append(String.format("%1$s<!-- %2$s -->\n", |
| offset, node.getNodeValue())); |
| break; |
| case Node.TEXT_NODE: |
| String txt = node.getNodeValue().trim(); |
| if (txt.isEmpty()) { |
| // Keep this for debugging. TODO make it a flag |
| // to dump whitespace on debugging. Otherwise ignore it. |
| // txt = "[whitespace]"; |
| break; |
| } |
| sb.append(String.format("%1$s%2$s\n", offset, txt)); |
| break; |
| case Node.ATTRIBUTE_NODE: |
| sb.append(String.format("%1$s @%2$s = %3$s\n", |
| offset, node.getNodeName(), node.getNodeValue())); |
| break; |
| case Node.CDATA_SECTION_NODE: |
| type = "cdata"; //$NON-NLS-1$ |
| break; |
| case Node.DOCUMENT_NODE: |
| type = "document"; //$NON-NLS-1$ |
| break; |
| case Node.PROCESSING_INSTRUCTION_NODE: |
| type = "PI"; //$NON-NLS-1$ |
| break; |
| default: |
| type = Integer.toString(t); |
| } |
| |
| if (type != null) { |
| sb.append(String.format("%1$s[%2$s] <%3$s> %4$s\n", |
| offset, type, node.getNodeName(), node.getNodeValue())); |
| } |
| |
| if (deep) { |
| for (Attr attr : sortedAttributeList(node.getAttributes())) { |
| sb.append(String.format("%1$s @%2$s = %3$s\n", |
| offset, attr.getNodeName(), attr.getNodeValue())); |
| } |
| |
| Node child = node.getFirstChild(); |
| if (child != null) { |
| sb.append(dump(child, offsetIndex+1, true, true, keyAttr)); |
| } |
| } |
| |
| if (!nextSiblings) { |
| break; |
| } |
| } |
| } |
| return sb.toString(); |
| } |
| |
| /** |
| * Returns a sorted list of attributes. |
| * The list is never null and does not contain null items. |
| * |
| * @param attrMap A Node map as returned by {@link Node#getAttributes()}. |
| * Can be null, in which case an empty list is returned. |
| * @return A non-null, possible empty, list of all nodes that are actual {@link Attr}, |
| * sorted by increasing attribute name. |
| */ |
| @NonNull |
| static List<Attr> sortedAttributeList(@Nullable NamedNodeMap attrMap) { |
| List<Attr> list = new ArrayList<Attr>(); |
| |
| if (attrMap != null) { |
| for (int i = 0; i < attrMap.getLength(); i++) { |
| Node attr = attrMap.item(i); |
| if (attr instanceof Attr) { |
| list.add((Attr) attr); |
| } |
| } |
| } |
| |
| if (list.size() > 1) { |
| // Sort it by attribute name |
| Collections.sort(list, getAttrComparator()); |
| } |
| |
| return list; |
| } |
| |
| /** |
| * Returns a comparator for {@link Attr}, alphabetically sorted by name. |
| * The "name" attribute is special and always sorted to the front. |
| */ |
| @NonNull |
| static Comparator<? super Attr> getAttrComparator() { |
| return new Comparator<Attr>() { |
| @Override |
| public int compare(Attr a1, Attr a2) { |
| String s1 = a1 == null ? "" : a1.getNodeName(); //$NON-NLS-1$ |
| String s2 = a2 == null ? "" : a2.getNodeName(); //$NON-NLS-1$ |
| |
| boolean name1 = s1.equals("name"); //$NON-NLS-1$ |
| boolean name2 = s2.equals("name"); //$NON-NLS-1$ |
| |
| if (name1 && name2) { |
| return 0; |
| } else if (name1) { |
| return -1; // name is always first |
| } else if (name2) { |
| return 1; // name is always first |
| } else { |
| return s1.compareTo(s2); |
| } |
| } |
| }; |
| } |
| |
| /** |
| * Inject attributes into an existing document. |
| * <p/> |
| * The map keys are "/manifest/elements...|attribute-ns-uri attribute-local-name", |
| * for example "/manifest/uses-sdk|http://schemas.android.com/apk/res/android minSdkVersion". |
| * (note the space separator between the attribute URI and its local name.) |
| * The elements will be created if they don't exists. Existing attributes will be modified. |
| * The replacement is done on the main document <em>before</em> merging. |
| * The value can be null to remove an existing attribute. |
| * |
| * @param doc The document to modify in-place. |
| * @param attributeMap A map of attributes to inject in the form [pseudo-xpath] => value. |
| * @param log A log in case of error. |
| */ |
| static void injectAttributes( |
| @Nullable Document doc, |
| @Nullable Map<String, String> attributeMap, |
| @NonNull IMergerLog log) { |
| if (doc == null || attributeMap == null || attributeMap.isEmpty()) { |
| return; |
| } |
| |
| // 1=path 2=URI 3=local name |
| final Pattern keyRx = Pattern.compile("^/([^\\|]+)\\|([^ ]*) +(.+)$"); //$NON-NLS-1$ |
| final FileAndLine docInfo = xmlFileAndLine(doc); |
| |
| nextAttribute: for (Entry<String, String> entry : attributeMap.entrySet()) { |
| String key = entry.getKey(); |
| String value = entry.getValue(); |
| if (key == null || key.isEmpty()) { |
| continue; |
| } |
| |
| Matcher m = keyRx.matcher(key); |
| if (!m.matches()) { |
| log.error(Severity.WARNING, docInfo, "Invalid injected attribute key: %s", key); |
| continue; |
| } |
| String path = m.group(1); |
| String attrNsUri = m.group(2); |
| String attrName = m.group(3); |
| |
| String[] segment = path.split(Pattern.quote("/")); //$NON-NLS-1$ |
| |
| // Get the path elements. Create them as needed if they don't exist. |
| Node element = doc; |
| nextSegment: for (int i = 0; i < segment.length; i++) { |
| // Find a child with the segment's name |
| String name = segment[i]; |
| for (Node child = element.getFirstChild(); |
| child != null; |
| child = child.getNextSibling()) { |
| if (child.getNodeType() == Node.ELEMENT_NODE && |
| child.getNamespaceURI() == null && |
| child.getNodeName().equals(name)) { |
| // Found it. Continue to the next inner segment. |
| element = child; |
| continue nextSegment; |
| } |
| } |
| // No such element. Create it. |
| if (value == null) { |
| // If value is null, we want to remove, not create and if can't find the |
| // element, then we're done: there's no such attribute to remove. |
| break nextAttribute; |
| } |
| |
| Element child = doc.createElement(name); |
| element = element.insertBefore(child, element.getFirstChild()); |
| } |
| |
| if (element == null) { |
| log.error(Severity.WARNING, docInfo, "Invalid injected attribute path: %s", path); |
| return; |
| } |
| |
| NamedNodeMap attrs = element.getAttributes(); |
| if (attrs != null) { |
| |
| |
| if (attrNsUri != null && attrNsUri.isEmpty()) { |
| attrNsUri = null; |
| } |
| Node attr = attrs.getNamedItemNS(attrNsUri, attrName); |
| |
| if (value == null) { |
| // We want to remove the attribute from the attribute map. |
| if (attr != null) { |
| attrs.removeNamedItemNS(attrNsUri, attrName); |
| } |
| |
| } else { |
| // We want to add or replace the attribute. |
| if (attr == null) { |
| attr = doc.createAttributeNS(attrNsUri, attrName); |
| if (attrNsUri != null) { |
| attr.setPrefix(XmlUtils.lookupNamespacePrefix(element, attrNsUri)); |
| } |
| attrs.setNamedItemNS(attr); |
| } |
| attr.setNodeValue(value); |
| } |
| } |
| } |
| } |
| |
| // ------- |
| |
| /** |
| * Flatten the element to a string. This "pretty prints" the XML tree starting |
| * from the given node and all its children and attributes. |
| * <p/> |
| * The output is designed to be printed using {@link #printXmlDiff}. |
| * |
| * @param node The root node to print. |
| * @param nsPrefix A map that is filled with all the URI=>prefix found. |
| * The internal string only contains the expanded URIs but this is rather verbose |
| * so when printing the diff these will be replaced by the prefixes collected here. |
| * @param prefix A "space" prefix added at the beginning of each line for indentation |
| * purposes. The diff printer later relies on this to find out the structure. |
| */ |
| @NonNull |
| static String printElement( |
| @NonNull Node node, |
| @NonNull Map<String, String> nsPrefix, |
| @NonNull String prefix) { |
| StringBuilder sb = new StringBuilder(); |
| sb.append(prefix).append('<'); |
| String uri = node.getNamespaceURI(); |
| if (uri != null) { |
| sb.append(uri).append(':'); |
| nsPrefix.put(uri, node.getPrefix()); |
| } |
| sb.append(node.getLocalName()); |
| printAttributes(sb, node, nsPrefix, prefix); |
| sb.append(">\n"); //$NON-NLS-1$ |
| printChildren(sb, node.getFirstChild(), true, nsPrefix, prefix + " "); //$NON-NLS-1$ |
| |
| sb.append(prefix).append("</"); //$NON-NLS-1$ |
| if (uri != null) { |
| sb.append(uri).append(':'); |
| } |
| sb.append(node.getLocalName()); |
| sb.append(">\n"); //$NON-NLS-1$ |
| |
| return sb.toString(); |
| } |
| |
| /** |
| * Flatten several children elements to a string. |
| * This is an implementation detail for {@link #printElement(Node, Map, String)}. |
| * <p/> |
| * If {@code nextSiblings} is false, the string conversion takes only the given |
| * child element and stops there. |
| * <p/> |
| * If {@code nextSiblings} is true, the string conversion also takes _all_ the siblings |
| * after the given element. The idea is the caller can call this with the first child |
| * of a parent and get a string showing all the children at the same time. They are |
| * sorted to avoid the ordering issue. |
| */ |
| @NonNull |
| private static StringBuilder printChildren( |
| @NonNull StringBuilder sb, |
| @NonNull Node child, |
| boolean nextSiblings, |
| @NonNull Map<String, String> nsPrefix, |
| @NonNull String prefix) { |
| ArrayList<String> children = new ArrayList<String>(); |
| |
| boolean hasText = false; |
| for (; child != null; child = child.getNextSibling()) { |
| short t = child.getNodeType(); |
| if (nextSiblings && t == Node.TEXT_NODE) { |
| // We don't typically have meaningful text nodes in an Android manifest. |
| // If there are, just dump them as-is into the element representation. |
| // We do trim whitespace and ignore all-whitespace or empty text nodes. |
| String s = child.getNodeValue().trim(); |
| if (!s.isEmpty()) { |
| sb.append(s); |
| hasText = true; |
| } |
| } else if (t == Node.ELEMENT_NODE) { |
| children.add(printElement(child, nsPrefix, prefix)); |
| if (!nextSiblings) { |
| break; |
| } |
| } |
| } |
| |
| if (hasText) { |
| sb.append('\n'); |
| } |
| |
| if (!children.isEmpty()) { |
| Collections.sort(children); |
| for (String s : children) { |
| sb.append(s); |
| } |
| } |
| |
| return sb; |
| } |
| |
| /** |
| * Flatten several attributes to a string using their alphabetical order. |
| * This is an implementation detail for {@link #printElement(Node, Map, String)}. |
| */ |
| @NonNull |
| private static StringBuilder printAttributes( |
| @NonNull StringBuilder sb, |
| @NonNull Node node, |
| @NonNull Map<String, String> nsPrefix, |
| @NonNull String prefix) { |
| ArrayList<String> attrs = new ArrayList<String>(); |
| |
| NamedNodeMap attrMap = node.getAttributes(); |
| if (attrMap != null) { |
| StringBuilder sb2 = new StringBuilder(); |
| for (int i = 0; i < attrMap.getLength(); i++) { |
| Node attr = attrMap.item(i); |
| if (attr instanceof Attr) { |
| sb2.setLength(0); |
| sb2.append('@'); |
| String uri = attr.getNamespaceURI(); |
| if (uri != null) { |
| sb2.append(uri).append(':'); |
| nsPrefix.put(uri, attr.getPrefix()); |
| } |
| sb2.append(attr.getLocalName()); |
| sb2.append("=\"").append(attr.getNodeValue()).append('\"'); //$NON-NLS-1$ |
| attrs.add(sb2.toString()); |
| } |
| } |
| } |
| |
| Collections.sort(attrs); |
| |
| for(String attr : attrs) { |
| sb.append('\n'); |
| sb.append(prefix).append(" ").append(attr); //$NON-NLS-1$ |
| } |
| return sb; |
| } |
| |
| //------------ |
| |
| /** |
| * Computes a quick diff between two strings generated by |
| * {@link #printElement(Node, Map, String)}. |
| * <p/> |
| * This is a <em>not</em> designed to be a full contextual diff. |
| * It just stops at the first difference found, printing up to 3 lines of diff |
| * and backtracking to add prior contextual information to understand the |
| * structure of the element where the first diff line occurred (by printing |
| * each parent found till the root one as well as printing the attribute |
| * named by {@code keyAttr}). |
| * |
| * @param sb The string builder where to output is written. |
| * @param expected The expected XML tree (as generated by {@link #printElement}.) |
| * For best result this would be the "destination" XML we're merging into, |
| * e.g. the main manifest. |
| * @param actual The actual XML tree (as generated by {@link #printElement}.) |
| * For best result this would be the "source" XML we're merging from, |
| * e.g. a library manifest. |
| * @param nsPrefixE The map of URI=>prefix for the expected XML tree. |
| * @param nsPrefixA The map of URI=>prefix for the actual XML tree. |
| * @param keyAttr An optional attribute *full* name (uri:local name) to always |
| * insert when writing the contextual lines before a diff line. |
| * For example when writing an Activity, it helps to always insert |
| * the "name" attribute since that's the key element to help the user |
| * identify which node is being dumped. |
| */ |
| static void printXmlDiff( |
| StringBuilder sb, |
| String expected, |
| String actual, |
| Map<String, String> nsPrefixE, |
| Map<String, String> nsPrefixA, |
| String keyAttr) { |
| String[] aE = expected.split("\n"); |
| String[] aA = actual.split("\n"); |
| int lE = aE.length; |
| int lA = aA.length; |
| int lm = lE < lA ? lA : lE; |
| boolean eofE = false; |
| boolean eofA = false; |
| boolean contextE = true; |
| boolean contextA = true; |
| int numDiff = 0; |
| |
| StringBuilder sE = new StringBuilder(); |
| StringBuilder sA = new StringBuilder(); |
| |
| outerLoop: for (int i = 0, iE = 0, iA = 0; i < lm; i++) { |
| if (iE < lE && iA < lA && aE[iE].equals(aA[iA])) { |
| if (numDiff > 0) { |
| // If we found a difference, stop now. |
| break outerLoop; |
| } |
| iE++; |
| iA++; |
| continue; |
| } else { |
| // Try to print some context for each side based on previous lines's space prefix. |
| if (contextE) { |
| if (iE > 0) { |
| String p = diffGetPrefix(aE[iE]); |
| for (int kE = iE-1; kE >= 0; kE--) { |
| if (!aE[kE].startsWith(p)) { |
| sE.insert(0, '\n').insert(0, diffReplaceNs(aE[kE], nsPrefixE)).insert(0, " "); |
| if (p.isEmpty()) { |
| break; |
| } |
| p = diffGetPrefix(aE[kE]); |
| } else if (aE[kE].contains(keyAttr) || kE == 0) { |
| sE.insert(0, '\n').insert(0, diffReplaceNs(aE[kE], nsPrefixE)).insert(0, " "); |
| } |
| } |
| } |
| contextE = false; |
| } |
| if (iE >= lE) { |
| if (!eofE) { |
| sE.append("--(end reached)\n"); |
| eofE = true; |
| } |
| } else { |
| sE.append("--").append(diffReplaceNs(aE[iE++], nsPrefixE)).append('\n'); |
| } |
| |
| if (contextA) { |
| if (iA > 0) { |
| String p = diffGetPrefix(aA[iA]); |
| for (int kA = iA-1; kA >= 0; kA--) { |
| if (!aA[kA].startsWith(p)) { |
| sA.insert(0, '\n').insert(0, diffReplaceNs(aA[kA], nsPrefixA)).insert(0, " "); |
| p = diffGetPrefix(aA[kA]); |
| if (p.isEmpty()) { |
| break; |
| } |
| } else if (aA[kA].contains(keyAttr) || kA == 0) { |
| sA.insert(0, '\n').insert(0, diffReplaceNs(aA[kA], nsPrefixA)).insert(0, " "); |
| } |
| } |
| } |
| contextA = false; |
| } |
| if (iA >= lA) { |
| if (!eofA) { |
| sA.append("++(end reached)\n"); |
| eofA = true; |
| } |
| } else { |
| sA.append("++").append(diffReplaceNs(aA[iA++], nsPrefixA)).append('\n'); |
| } |
| |
| // Dump up to 3 lines of difference |
| numDiff++; |
| if (numDiff == 3) { |
| break outerLoop; |
| } |
| } |
| } |
| |
| sb.append(sE); |
| sb.append(sA); |
| } |
| |
| /** |
| * Returns all the whitespace at the beginning of a string. |
| * Implementation details for {@link #printXmlDiff} used to find the "parent" |
| * element and include it in the context of the diff. |
| */ |
| private static String diffGetPrefix(String str) { |
| int pos = 0; |
| int len = str.length(); |
| while (pos < len && str.charAt(pos) == ' ') { |
| pos++; |
| } |
| return str.substring(0, pos); |
| } |
| |
| /** |
| * Simplifies a diff line by replacing NS URIs by their prefix. |
| * Implementation details for {@link #printXmlDiff}. |
| */ |
| private static String diffReplaceNs(String str, Map<String, String> nsPrefix) { |
| for (Entry<String, String> entry : nsPrefix.entrySet()) { |
| String uri = entry.getKey(); |
| String prefix = entry.getValue(); |
| if (prefix != null && str.contains(uri)) { |
| str = str.replaceAll(Pattern.quote(uri), Matcher.quoteReplacement(prefix)); |
| } |
| } |
| return str; |
| } |
| |
| /** |
| * Returns the file associated with the given specific node, if any. |
| * Note that this will not search upwards for parent nodes; it returns a |
| * file associated with this specific node, if any. |
| */ |
| @Nullable |
| public static File getFileFor(@NonNull Node node) { |
| return (File) node.getUserData(DATA_ORIGIN_FILE); |
| } |
| |
| /** |
| * Sets the file associated with the given node, if any |
| */ |
| public static void setFileFor(Node node, File file) { |
| node.setUserData(MergerXmlUtils.DATA_ORIGIN_FILE, file, null); |
| } |
| } |
