| /* |
| * Copyright (C) 2014 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 android.databinding.tool.util; |
| |
| import org.antlr.v4.runtime.ANTLRInputStream; |
| import org.antlr.v4.runtime.CommonTokenStream; |
| import org.antlr.v4.runtime.Token; |
| import org.antlr.v4.runtime.tree.TerminalNode; |
| import org.apache.commons.io.FileUtils; |
| import org.apache.commons.lang3.StringEscapeUtils; |
| import org.apache.commons.lang3.StringUtils; |
| import org.apache.commons.lang3.tuple.ImmutablePair; |
| import org.apache.commons.lang3.tuple.Pair; |
| |
| import android.databinding.parser.BindingExpressionLexer; |
| import android.databinding.parser.BindingExpressionParser; |
| import android.databinding.parser.XMLLexer; |
| import android.databinding.parser.XMLParser; |
| import android.databinding.parser.XMLParser.AttributeContext; |
| import android.databinding.parser.XMLParser.ElementContext; |
| |
| import java.io.File; |
| import java.io.FileReader; |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.List; |
| |
| /** |
| * Ugly inefficient class to strip unwanted tags from XML. |
| * Band-aid solution to unblock development |
| */ |
| public class XmlEditor { |
| |
| public static String strip(File f, String newTag) throws IOException { |
| ANTLRInputStream inputStream = new ANTLRInputStream(new FileReader(f)); |
| XMLLexer lexer = new XMLLexer(inputStream); |
| CommonTokenStream tokenStream = new CommonTokenStream(lexer); |
| XMLParser parser = new XMLParser(tokenStream); |
| XMLParser.DocumentContext expr = parser.document(); |
| XMLParser.ElementContext root = expr.element(); |
| |
| if (root == null || !"layout".equals(nodeName(root))) { |
| return null; // not a binding layout |
| } |
| |
| List<? extends ElementContext> childrenOfRoot = elements(root); |
| List<? extends XMLParser.ElementContext> dataNodes = filterNodesByName("data", |
| childrenOfRoot); |
| if (dataNodes.size() > 1) { |
| L.e("Multiple binding data tags in %s. Expecting a maximum of one.", |
| f.getAbsolutePath()); |
| } |
| |
| ArrayList<String> lines = new ArrayList<>(); |
| lines.addAll(FileUtils.readLines(f, "utf-8")); |
| |
| for (android.databinding.parser.XMLParser.ElementContext it : dataNodes) { |
| replace(lines, toPosition(it.getStart()), toEndPosition(it.getStop()), ""); |
| } |
| List<? extends XMLParser.ElementContext> layoutNodes = |
| excludeNodesByName("data", childrenOfRoot); |
| if (layoutNodes.size() != 1) { |
| L.e("Only one layout element and one data element are allowed. %s has %d", |
| f.getAbsolutePath(), layoutNodes.size()); |
| } |
| |
| final XMLParser.ElementContext layoutNode = layoutNodes.get(0); |
| |
| ArrayList<Pair<String, android.databinding.parser.XMLParser.ElementContext>> noTag = |
| new ArrayList<>(); |
| |
| recurseReplace(layoutNode, lines, noTag, newTag, 0); |
| |
| // Remove the <layout> |
| Position rootStartTag = toPosition(root.getStart()); |
| Position rootEndTag = toPosition(root.content().getStart()); |
| replace(lines, rootStartTag, rootEndTag, ""); |
| |
| // Remove the </layout> |
| ImmutablePair<Position, Position> endLayoutPositions = findTerminalPositions(root, lines); |
| replace(lines, endLayoutPositions.left, endLayoutPositions.right, ""); |
| |
| StringBuilder rootAttributes = new StringBuilder(); |
| for (AttributeContext attr : attributes(root)) { |
| rootAttributes.append(' ').append(attr.getText()); |
| } |
| Pair<String, XMLParser.ElementContext> noTagRoot = null; |
| for (Pair<String, XMLParser.ElementContext> pair : noTag) { |
| if (pair.getRight() == layoutNode) { |
| noTagRoot = pair; |
| break; |
| } |
| } |
| if (noTagRoot != null) { |
| ImmutablePair<String, XMLParser.ElementContext> |
| newRootTag = new ImmutablePair<>( |
| noTagRoot.getLeft() + rootAttributes.toString(), layoutNode); |
| int index = noTag.indexOf(noTagRoot); |
| noTag.set(index, newRootTag); |
| } else { |
| ImmutablePair<String, XMLParser.ElementContext> newRootTag = |
| new ImmutablePair<>(rootAttributes.toString(), layoutNode); |
| noTag.add(newRootTag); |
| } |
| //noinspection NullableProblems |
| Collections.sort(noTag, new Comparator<Pair<String, XMLParser.ElementContext>>() { |
| @Override |
| public int compare(Pair<String, XMLParser.ElementContext> o1, |
| Pair<String, XMLParser.ElementContext> o2) { |
| Position start1 = toPosition(o1.getRight().getStart()); |
| Position start2 = toPosition(o2.getRight().getStart()); |
| int lineCmp = Integer.compare(start2.line, start1.line); |
| if (lineCmp != 0) { |
| return lineCmp; |
| } |
| return Integer.compare(start2.charIndex, start1.charIndex); |
| } |
| }); |
| for (Pair<String, android.databinding.parser.XMLParser.ElementContext> it : noTag) { |
| XMLParser.ElementContext element = it.getRight(); |
| String tag = it.getLeft(); |
| Position endTagPosition = endTagPosition(element); |
| fixPosition(lines, endTagPosition); |
| String line = lines.get(endTagPosition.line); |
| String newLine = line.substring(0, endTagPosition.charIndex) + " " + tag + |
| line.substring(endTagPosition.charIndex); |
| lines.set(endTagPosition.line, newLine); |
| } |
| return StringUtils.join(lines, System.getProperty("line.separator")); |
| } |
| |
| private static <T extends XMLParser.ElementContext> List<T> |
| filterNodesByName(String name, Iterable<T> items) { |
| List<T> result = new ArrayList<>(); |
| for (T item : items) { |
| if (name.equals(nodeName(item))) { |
| result.add(item); |
| } |
| } |
| return result; |
| } |
| |
| private static <T extends XMLParser.ElementContext> List<T> |
| excludeNodesByName(String name, Iterable<T> items) { |
| List<T> result = new ArrayList<>(); |
| for (T item : items) { |
| if (!name.equals(nodeName(item))) { |
| result.add(item); |
| } |
| } |
| return result; |
| } |
| |
| private static Position toPosition(Token token) { |
| return new Position(token.getLine() - 1, token.getCharPositionInLine()); |
| } |
| |
| private static Position toEndPosition(Token token) { |
| return new Position(token.getLine() - 1, |
| token.getCharPositionInLine() + token.getText().length()); |
| } |
| |
| public static String nodeName(XMLParser.ElementContext elementContext) { |
| return elementContext.elmName.getText(); |
| } |
| |
| public static List<? extends AttributeContext> attributes(XMLParser.ElementContext elementContext) { |
| if (elementContext.attribute() == null) { |
| return new ArrayList<>(); |
| } else { |
| return elementContext.attribute(); |
| } |
| } |
| |
| public static List<? extends AttributeContext> expressionAttributes ( |
| XMLParser.ElementContext elementContext) { |
| List<AttributeContext> result = new ArrayList<>(); |
| for (AttributeContext input : attributes(elementContext)) { |
| String attrName = input.attrName.getText(); |
| String value = input.attrValue.getText(); |
| if (attrName.equals("android:tag") || |
| (value.startsWith("\"@{") && value.endsWith("}\"")) || |
| (value.startsWith("'@{") && value.endsWith("}'"))) { |
| result.add(input); |
| } |
| } |
| return result; |
| } |
| |
| private static Position endTagPosition(XMLParser.ElementContext context) { |
| if (context.content() == null) { |
| // no content, so just subtract from the "/>" |
| Position endTag = toEndPosition(context.getStop()); |
| if (endTag.charIndex <= 0) { |
| L.e("invalid input in %s", context); |
| } |
| endTag.charIndex -= 2; |
| return endTag; |
| } else { |
| // tag with no attributes, but with content |
| Position position = toPosition(context.content().getStart()); |
| if (position.charIndex <= 0) { |
| L.e("invalid input in %s", context); |
| } |
| position.charIndex--; |
| return position; |
| } |
| } |
| |
| public static List<? extends android.databinding.parser.XMLParser.ElementContext> elements( |
| XMLParser.ElementContext context) { |
| if (context.content() != null && context.content().element() != null) { |
| return context.content().element(); |
| } |
| return new ArrayList<>(); |
| } |
| |
| private static boolean replace(ArrayList<String> lines, Position start, Position end, |
| String text) { |
| fixPosition(lines, start); |
| fixPosition(lines, end); |
| if (start.line != end.line) { |
| String startLine = lines.get(start.line); |
| String newStartLine = startLine.substring(0, start.charIndex) + text; |
| lines.set(start.line, newStartLine); |
| for (int i = start.line + 1; i < end.line; i++) { |
| String line = lines.get(i); |
| lines.set(i, replaceWithSpaces(line, 0, line.length() - 1)); |
| } |
| String endLine = lines.get(end.line); |
| String newEndLine = replaceWithSpaces(endLine, 0, end.charIndex - 1); |
| lines.set(end.line, newEndLine); |
| return true; |
| } else if (end.charIndex - start.charIndex >= text.length()) { |
| String line = lines.get(start.line); |
| int endTextIndex = start.charIndex + text.length(); |
| String replacedText = replaceRange(line, start.charIndex, endTextIndex, text); |
| String spacedText = replaceWithSpaces(replacedText, endTextIndex, end.charIndex - 1); |
| lines.set(start.line, spacedText); |
| return true; |
| } else { |
| String line = lines.get(start.line); |
| String newLine = replaceWithSpaces(line, start.charIndex, end.charIndex - 1); |
| lines.set(start.line, newLine); |
| return false; |
| } |
| } |
| |
| private static String replaceRange(String line, int start, int end, String newText) { |
| return line.substring(0, start) + newText + line.substring(end); |
| } |
| |
| public static boolean hasExpressionAttributes(XMLParser.ElementContext context) { |
| List<? extends AttributeContext> expressions = expressionAttributes(context); |
| int size = expressions.size(); |
| //noinspection ConstantConditions |
| return size > 1 || (size == 1 && |
| !expressions.get(0).attrName.getText().equals("android:tag")); |
| } |
| |
| private static int recurseReplace(XMLParser.ElementContext node, ArrayList<String> lines, |
| ArrayList<Pair<String, XMLParser.ElementContext>> noTag, |
| String newTag, int bindingIndex) { |
| int nextBindingIndex = bindingIndex; |
| boolean isMerge = "merge".equals(nodeName(node)); |
| final boolean containsInclude = filterNodesByName("include", elements(node)).size() > 0; |
| if (!isMerge && (hasExpressionAttributes(node) || newTag != null || containsInclude)) { |
| String tag = ""; |
| if (newTag != null) { |
| tag = "android:tag=\"" + newTag + "_" + bindingIndex + "\""; |
| nextBindingIndex++; |
| } else if (!"include".equals(nodeName(node))) { |
| tag = "android:tag=\"binding_" + bindingIndex + "\""; |
| nextBindingIndex++; |
| } |
| for (AttributeContext it : expressionAttributes(node)) { |
| Position start = toPosition(it.getStart()); |
| Position end = toEndPosition(it.getStop()); |
| String defaultVal = defaultReplacement(it); |
| if (defaultVal != null) { |
| replace(lines, start, end, it.attrName.getText() + "=\"" + defaultVal + "\""); |
| } else if (replace(lines, start, end, tag)) { |
| tag = ""; |
| } |
| } |
| if (tag.length() != 0) { |
| noTag.add(new ImmutablePair<>(tag, node)); |
| } |
| } |
| |
| String nextTag; |
| if (bindingIndex == 0 && isMerge) { |
| nextTag = newTag; |
| } else { |
| nextTag = null; |
| } |
| for (XMLParser.ElementContext it : elements(node)) { |
| nextBindingIndex = recurseReplace(it, lines, noTag, nextTag, nextBindingIndex); |
| } |
| return nextBindingIndex; |
| } |
| |
| private static String defaultReplacement(XMLParser.AttributeContext attr) { |
| String textWithQuotes = attr.attrValue.getText(); |
| String escapedText = textWithQuotes.substring(1, textWithQuotes.length() - 1); |
| if (!escapedText.startsWith("@{") || !escapedText.endsWith("}")) { |
| return null; |
| } |
| String text = StringEscapeUtils |
| .unescapeXml(escapedText.substring(2, escapedText.length() - 1)); |
| ANTLRInputStream inputStream = new ANTLRInputStream(text); |
| BindingExpressionLexer lexer = new BindingExpressionLexer(inputStream); |
| CommonTokenStream tokenStream = new CommonTokenStream(lexer); |
| BindingExpressionParser parser = new BindingExpressionParser(tokenStream); |
| BindingExpressionParser.BindingSyntaxContext root = parser.bindingSyntax(); |
| BindingExpressionParser.DefaultsContext defaults = root.defaults(); |
| if (defaults != null) { |
| BindingExpressionParser.ConstantValueContext constantValue = defaults |
| .constantValue(); |
| BindingExpressionParser.LiteralContext literal = constantValue.literal(); |
| if (literal != null) { |
| BindingExpressionParser.StringLiteralContext stringLiteral = literal |
| .stringLiteral(); |
| if (stringLiteral != null) { |
| TerminalNode doubleQuote = stringLiteral.DoubleQuoteString(); |
| if (doubleQuote != null) { |
| String quotedStr = doubleQuote.getText(); |
| String unquoted = quotedStr.substring(1, quotedStr.length() - 1); |
| return StringEscapeUtils.escapeXml10(unquoted); |
| } else { |
| String quotedStr = stringLiteral.SingleQuoteString().getText(); |
| String unquoted = quotedStr.substring(1, quotedStr.length() - 1); |
| String unescaped = unquoted.replace("\"", "\\\"").replace("\\`", "`"); |
| return StringEscapeUtils.escapeXml10(unescaped); |
| } |
| } |
| } |
| return constantValue.getText(); |
| } |
| return null; |
| } |
| |
| private static ImmutablePair<Position, Position> findTerminalPositions( |
| XMLParser.ElementContext node, ArrayList<String> lines) { |
| Position endPosition = toEndPosition(node.getStop()); |
| Position startPosition = toPosition(node.getStop()); |
| int index; |
| do { |
| index = lines.get(startPosition.line).lastIndexOf("</"); |
| startPosition.line--; |
| } while (index < 0); |
| startPosition.line++; |
| startPosition.charIndex = index; |
| //noinspection unchecked |
| return new ImmutablePair<>(startPosition, endPosition); |
| } |
| |
| private static String replaceWithSpaces(String line, int start, int end) { |
| StringBuilder lineBuilder = new StringBuilder(line); |
| for (int i = start; i <= end; i++) { |
| lineBuilder.setCharAt(i, ' '); |
| } |
| return lineBuilder.toString(); |
| } |
| |
| private static void fixPosition(ArrayList<String> lines, Position pos) { |
| String line = lines.get(pos.line); |
| while (pos.charIndex > line.length()) { |
| pos.charIndex--; |
| } |
| } |
| |
| private static class Position { |
| |
| int line; |
| int charIndex; |
| |
| public Position(int line, int charIndex) { |
| this.line = line; |
| this.charIndex = charIndex; |
| } |
| } |
| |
| } |