1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 package org.htmlunit.html.serializer;
16
17 import static org.htmlunit.BrowserVersionFeatures.JS_INNER_HTML_XHTML_BOOLEAN_ATTRIBUTE_VALUE;
18 import static org.htmlunit.BrowserVersionFeatures.JS_INNER_HTML_XHTML_HEX_LINE_BREAK;
19 import static org.htmlunit.BrowserVersionFeatures.JS_INNER_HTML_XHTML_NS_DECLARATION_AFTER_ATTRIBUTE;
20
21 import java.util.Collection;
22 import java.util.HashMap;
23 import java.util.Map;
24 import java.util.Objects;
25 import java.util.Set;
26
27 import javax.xml.XMLConstants;
28
29 import org.htmlunit.BrowserVersion;
30 import org.htmlunit.html.DomAttr;
31 import org.htmlunit.html.DomCDataSection;
32 import org.htmlunit.html.DomComment;
33 import org.htmlunit.html.DomDocumentFragment;
34 import org.htmlunit.html.DomElement;
35 import org.htmlunit.html.DomNode;
36 import org.htmlunit.html.DomProcessingInstruction;
37 import org.htmlunit.html.DomText;
38 import org.htmlunit.html.Html;
39 import org.htmlunit.html.HtmlElement;
40 import org.htmlunit.html.HtmlTemplate;
41 import org.htmlunit.util.StringUtils;
42 import org.htmlunit.util.XmlUtils;
43
44
45
46
47
48
49
50
51
52
53
54 public final class XmlMarkupSerializer {
55
56
57 private static final Set<String> BOOLEAN_ATTRIBUTES = Set.of(
58 "checked", "compact", "declare", "defer", "disabled", "ismap", "multiple",
59 "nohref", "noresize", "noshade", "nowrap", "readonly", "selected");
60
61
62 private static final String XMLNS_PREFIX = XMLConstants.XMLNS_ATTRIBUTE + ":";
63
64 private final boolean booleanAttributeValue_;
65 private final boolean hexLineBreak_;
66 private final boolean declarationAfterAttribute_;
67
68
69
70
71
72
73 private XmlMarkupSerializer(final BrowserVersion browserVersion) {
74 booleanAttributeValue_ = browserVersion.hasFeature(JS_INNER_HTML_XHTML_BOOLEAN_ATTRIBUTE_VALUE);
75 hexLineBreak_ = browserVersion.hasFeature(JS_INNER_HTML_XHTML_HEX_LINE_BREAK);
76 declarationAfterAttribute_ = browserVersion.hasFeature(JS_INNER_HTML_XHTML_NS_DECLARATION_AFTER_ATTRIBUTE);
77 }
78
79
80
81
82
83
84
85
86 public static String serializeChildren(final DomNode node, final BrowserVersion browserVersion) {
87 final StringBuilder builder = new StringBuilder();
88 new XmlMarkupSerializer(browserVersion).appendChildren(builder, node, null, newPrefixMap());
89 return builder.toString();
90 }
91
92
93
94
95
96
97
98
99 public static String serialize(final DomNode node, final BrowserVersion browserVersion) {
100 final StringBuilder builder = new StringBuilder();
101 new XmlMarkupSerializer(browserVersion).appendNode(builder, node, null, newPrefixMap());
102 return builder.toString();
103 }
104
105
106
107
108
109
110 private static Map<String, String> newPrefixMap() {
111 final Map<String, String> prefixMap = new HashMap<>();
112 prefixMap.put(XMLConstants.XML_NS_PREFIX, XMLConstants.XML_NS_URI);
113 return prefixMap;
114 }
115
116
117
118
119
120
121
122
123
124
125 private void appendChildren(final StringBuilder builder, final DomNode node,
126 final String contextNamespace, final Map<String, String> prefixMap) {
127 final DomNode parent = node instanceof HtmlTemplate template ? template.getContent() : node;
128 for (final DomNode child : parent.getChildren()) {
129 appendNode(builder, child, contextNamespace, prefixMap);
130 }
131 }
132
133
134
135
136
137
138
139
140
141 private void appendNode(final StringBuilder builder, final DomNode node,
142 final String contextNamespace, final Map<String, String> prefixMap) {
143 if (node instanceof DomElement element) {
144 appendElement(builder, element, contextNamespace, prefixMap);
145 }
146 else if (node instanceof DomCDataSection) {
147 builder.append("<![CDATA[").append(node.getNodeValue()).append("]]>");
148 }
149 else if (node instanceof DomComment) {
150 builder.append("<!--").append(node.getNodeValue()).append("-->");
151 }
152 else if (node instanceof DomText) {
153 builder.append(StringUtils.escapeXmlChars(node.getNodeValue()));
154 }
155 else if (node instanceof DomProcessingInstruction pi) {
156 builder.append("<?").append(pi.getTarget());
157 final String data = pi.getData();
158 if (!StringUtils.isEmptyOrNull(data)) {
159 builder.append(' ').append(data);
160 }
161 builder.append("?>");
162 }
163 else if (node instanceof DomDocumentFragment) {
164 appendChildren(builder, node, contextNamespace, prefixMap);
165 }
166 }
167
168
169
170
171
172
173
174
175
176 private void appendElement(final StringBuilder builder, final DomElement element,
177 final String contextNamespace, final Map<String, String> contextPrefixMap) {
178 final String namespace = namespaceOf(element);
179 final String prefix = element.getPrefix();
180 final Collection<DomAttr> attributes = element.getAttributesMap().values();
181
182
183
184 Map<String, String> prefixMap = contextPrefixMap;
185
186
187 String localDefaultNamespace = null;
188 boolean hasDefaultNamespaceAttribute = false;
189 for (final DomAttr attr : attributes) {
190 final String name = attr.getName();
191 if (XMLConstants.XMLNS_ATTRIBUTE.equals(name)) {
192 hasDefaultNamespaceAttribute = true;
193 localDefaultNamespace = StringUtils.isEmptyOrNull(attr.getValue()) ? null : attr.getValue();
194 }
195 else if (name.startsWith(XMLNS_PREFIX)) {
196 prefixMap = writablePrefixMap(prefixMap, contextPrefixMap);
197 prefixMap.put(name.substring(XMLNS_PREFIX.length()), attr.getValue());
198 }
199 }
200
201 final String qualifiedName = prefix == null ? element.getLocalName() : prefix + ":" + element.getLocalName();
202 builder.append('<').append(qualifiedName);
203
204 String childNamespace = contextNamespace;
205 if (prefix != null) {
206 if (!Objects.equals(prefixMap.get(prefix), namespace)) {
207 appendDeclaration(builder, prefix, namespace);
208 prefixMap = writablePrefixMap(prefixMap, contextPrefixMap);
209 prefixMap.put(prefix, namespace);
210 }
211 }
212 else if (hasDefaultNamespaceAttribute) {
213 childNamespace = localDefaultNamespace;
214 }
215 else {
216 if (!Objects.equals(namespace, contextNamespace)) {
217 appendDeclaration(builder, null, namespace);
218 }
219 childNamespace = namespace;
220 }
221
222
223
224 if (!declarationAfterAttribute_) {
225 for (final DomAttr attr : attributes) {
226 if (isUndeclaredAttributePrefix(attr, prefixMap)) {
227 appendDeclaration(builder, attr.getPrefix(), attr.getNamespaceURI());
228 prefixMap = writablePrefixMap(prefixMap, contextPrefixMap);
229 prefixMap.put(attr.getPrefix(), attr.getNamespaceURI());
230 }
231 }
232 }
233
234 for (final DomAttr attr : attributes) {
235 final boolean declare = declarationAfterAttribute_ && isUndeclaredAttributePrefix(attr, prefixMap);
236 if (attr.getSpecified()) {
237 builder.append(' ').append(attr.getName()).append("=\"")
238 .append(attributeValue(attr, namespace)).append('"');
239 if (declare) {
240 appendDeclaration(builder, attr.getPrefix(), attr.getNamespaceURI());
241 }
242 }
243 if (declare) {
244 prefixMap = writablePrefixMap(prefixMap, contextPrefixMap);
245 prefixMap.put(attr.getPrefix(), attr.getNamespaceURI());
246 }
247 }
248
249 final DomNode contentParent = element instanceof HtmlTemplate template ? template.getContent() : element;
250 if (contentParent.getFirstChild() == null) {
251 if (Html.XHTML_NAMESPACE.equals(namespace)) {
252
253 if (HtmlElement.isVoidElement(element.getLocalName())) {
254 builder.append(" />");
255 return;
256 }
257 builder.append("></").append(qualifiedName).append('>');
258 return;
259 }
260 builder.append("/>");
261 return;
262 }
263
264 builder.append('>');
265 appendChildren(builder, element, childNamespace, prefixMap);
266 builder.append("</").append(qualifiedName).append('>');
267 }
268
269
270
271
272
273
274
275
276
277 private static Map<String, String> writablePrefixMap(final Map<String, String> prefixMap,
278 final Map<String, String> contextPrefixMap) {
279 if (prefixMap == contextPrefixMap) {
280 return new HashMap<>(contextPrefixMap);
281 }
282 return prefixMap;
283 }
284
285
286
287
288
289
290
291
292
293 private static boolean isUndeclaredAttributePrefix(final DomAttr attr, final Map<String, String> prefixMap) {
294 final String attrNamespace = attr.getNamespaceURI();
295 final String attrPrefix = attr.getPrefix();
296 return attrNamespace != null && attrPrefix != null
297 && !XMLConstants.XML_NS_URI.equals(attrNamespace)
298 && !XMLConstants.XMLNS_ATTRIBUTE_NS_URI.equals(attrNamespace)
299 && !XMLConstants.XMLNS_ATTRIBUTE.equals(attrPrefix)
300 && !attrNamespace.equals(prefixMap.get(attrPrefix));
301 }
302
303
304
305
306
307
308
309
310 private String attributeValue(final DomAttr attr, final String elementNamespace) {
311 String value = attr.getValue();
312 if (booleanAttributeValue_
313 && StringUtils.isEmptyOrNull(value)
314 && attr.getPrefix() == null
315 && Html.XHTML_NAMESPACE.equals(elementNamespace)
316 && BOOLEAN_ATTRIBUTES.contains(attr.getName())) {
317 value = attr.getName();
318 }
319
320 value = XmlUtils.escapeXmlAttributeValue(value);
321 if (hexLineBreak_) {
322 value = value.replace(" ", "
").replace(" ", "
");
323 }
324 return value;
325 }
326
327
328
329
330
331
332
333
334 private static void appendDeclaration(final StringBuilder builder, final String prefix, final String namespace) {
335 builder.append(' ').append(XMLConstants.XMLNS_ATTRIBUTE);
336 if (prefix != null) {
337 builder.append(':').append(prefix);
338 }
339 builder.append("=\"");
340 if (namespace != null) {
341 builder.append(XmlUtils.escapeXmlAttributeValue(namespace));
342 }
343 builder.append('"');
344 }
345
346
347
348
349
350
351
352
353 private static String namespaceOf(final DomElement element) {
354 final String namespace = element.getNamespaceURI();
355 if (StringUtils.isEmptyOrNull(namespace)) {
356 return element instanceof HtmlElement ? Html.XHTML_NAMESPACE : null;
357 }
358 return namespace;
359 }
360 }