5078784284

Build Type

push

github

Committed by Jos Verburg

Commit Message

Set attributes using the localname and namespace instead of nodename when using XQUF

Run Details

4902 of 5699 branches covered (86.02%)

Branch coverage included in aggregate %.

10 of 10 new or added lines in 1 file covered. (100.0%)

29 existing lines in 3 files now uncovered.

10517 of 11153 relevant lines covered (94.3%)

96653.39 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.1

/src/expressions/xquery-update/applyPulPrimitives.ts

import IDocumentWriter from '../../documentWriter/IDocumentWriter';
import {
        AttributeNodePointer,
        ChildNodePointer,
        DocumentNodePointer,
        ElementNodePointer,
        NodePointer,
        ProcessingInstructionNodePointer,
        TinyElementNode,
} from '../../domClone/Pointer';
import { ConcreteElementNode, NODE_TYPES } from '../../domFacade/ConcreteNode';
import DomFacade from '../../domFacade/DomFacade';
import DomBackedNodesFactory from '../../nodesFactory/DomBackedNodesFactory';
import INodesFactory from '../../nodesFactory/INodesFactory';
import { Attr, Document, Element } from '../../types/Types';
import QName from '../dataTypes/valueTypes/QName';
import { errXUDY0021 } from './XQueryUpdateFacilityErrors';

function hasAttribute(
        target: ElementNodePointer,
        localName: string,
        namespace: string,
        domFacade: DomFacade
): boolean {
        return domFacade
                .getAllAttributePointers(target, `name-${localName}`)
                .some(
                        (attr) =>
                                domFacade.getLocalName(attr) === localName &&
                                domFacade.getNamespaceURI(attr) === namespace
                );
}

/**
 * Deletes $target.
 *
 * @param  target          The target to delete.
 * @param  domFacade       The domFacade (or DomFacade like interface) for retrieving relations.
 * @param  documentWriter  The documentWriter for writing changes.
 */
export const deletePu = (
        target: AttributeNodePointer | ChildNodePointer,
        domFacade: (DomFacade | null) | undefined,
        documentWriter: (IDocumentWriter | null) | undefined
) => {
        const parentPointer = domFacade.getParentNodePointer(target);
        const parent = parentPointer ? parentPointer.node : null;
        if (parent) {
                if (domFacade.getNodeType(target) === NODE_TYPES.ATTRIBUTE_NODE) {
                        documentWriter.removeAttributeNS(
                                parent as Element,
                                domFacade.getNamespaceURI(target as AttributeNodePointer),
                                domFacade.getLocalName(target as AttributeNodePointer)
                        );
                } else {
                        documentWriter.removeChild(parent as Document | Element, target.node);
                }
        }
};

/**
 * Inserts $content immediately after $target.
 *
 * @param  target          The target to insert after.
 * @param  content         The content.
 * @param  domFacade       The domFacade (or DomFacade like interface) for retrieving relations.
 * @param  documentWriter  The documentWriter for writing changes.
 */
export const insertAfter = (
        target: ChildNodePointer,
        content: NodePointer[],
        domFacade: (DomFacade | null) | undefined,
        documentWriter: (IDocumentWriter | null) | undefined
) => {
        // The parent must exist or an error has been raised.
        const parent = domFacade.getParentNodePointer(target).node;
        const nextSiblingPointer = domFacade.getNextSiblingPointer(target);
        const nextSibling = nextSiblingPointer ? nextSiblingPointer.node : null;

        content.forEach((pointer) => {
                documentWriter.insertBefore(parent as Element, pointer.node, nextSibling);
        });
};

/**
 * Inserts $content immediately before $target.
 *
 * @param  target          The target to insert before.
 * @param  content         The content.
 * @param  domFacade       The domFacade (or DomFacade like interface) for retrieving relations.
 * @param  documentWriter  The documentWriter for writing changes.
 */
export const insertBefore = (
        target: ChildNodePointer,
        content: NodePointer[],
        domFacade: (DomFacade | null) | undefined,
        documentWriter: (IDocumentWriter | null) | undefined
) => {
        // The parent must exist or an error has been raised.
        const parent = domFacade.getParentNodePointer(target).node;

        content.forEach((pointer) => {
                documentWriter.insertBefore(parent as Element, pointer.node, target.node);
        });
};

/**
 * Inserts $content as the children of $target, in an implementation-dependent position.
 *
 * @param  target          The target to insert into.
 * @param  content         The content.
 * @param  documentWriter  The documentWriter for writing changes.
 */
export const insertInto = (
        target: ElementNodePointer | DocumentNodePointer,
        content: NodePointer[],
        documentWriter: (IDocumentWriter | null) | undefined
) => {
        insertIntoAsLast(target, content, documentWriter);
};

/**
 * Inserts $content as the first children of $target.
 *
 * @param  target          The target to insert into.
 * @param  content         The content.
 * @param  domFacade       The domFacade (or DomFacade like interface) for retrieving relations.
 * @param  documentWriter  The documentWriter for writing changes.
 */
export const insertIntoAsFirst = (
        target: ElementNodePointer | DocumentNodePointer,
        content: NodePointer[],
        domFacade: (DomFacade | null) | undefined,
        documentWriter: (IDocumentWriter | null) | undefined
) => {
        const firstChildPointer = domFacade.getFirstChildPointer(target);
        const firstChild = firstChildPointer ? firstChildPointer.node : null;
        content.forEach((pointer) => {
                documentWriter.insertBefore(target.node, pointer.node, firstChild);
        });
};

/**
 * Inserts $content as the last children of $target.
 *
 * @param  target          The target to insert into.
 * @param  content         The content.
 * @param  documentWriter  The documentWriter for writing changes.
 */
export const insertIntoAsLast = (
        target: ElementNodePointer | DocumentNodePointer,
        content: NodePointer[],
        documentWriter: (IDocumentWriter | null) | undefined
) => {
        content.forEach((pointer) => {
                documentWriter.insertBefore(target.node, pointer.node, null);
        });
};

/**
 * Inserts $content as attributes of $target.
 *
 * @param  target          The target to insert into.
 * @param  content         The content.
 * @param  domFacade       The domFacade (or DomFacade like interface) for retrieving relations.
 * @param  documentWriter  The documentWriter for writing changes.
 */
export const insertAttributes = (
        target: ElementNodePointer,
        content: AttributeNodePointer[],
        domFacade: (DomFacade | null) | undefined,
        documentWriter: (IDocumentWriter | null) | undefined
) => {
        content.forEach((attributeNodePointer) => {
                const attrLocalName = domFacade.getLocalName(attributeNodePointer);
                const attrNamespace = domFacade.getNamespaceURI(attributeNodePointer);
                if (hasAttribute(target, attrLocalName, attrNamespace, domFacade)) {
                        throw errXUDY0021(
                                `An attribute ${
                                        attrNamespace ? `Q{${attrNamespace}}${attrLocalName}` : attrLocalName
                                } already exists.`
                        );
                }
                documentWriter.setAttributeNS(
                        target.node,
                        attrNamespace,
                        attrLocalName,
                        domFacade.getDataFromPointer(attributeNodePointer)
                );
        });
};

/**
 * Changes the node-name of $target to $newName.
 *
 * @param  target          The target to replace.
 * @param  newName         The new name.
 * @param  domFacade       The domFacade (or DomFacade like interface) for retrieving relations.
 * @param  nodesFactory    The nodesFactory for creating nodes.
 * @param  documentWriter  The documentWriter for writing changes.
 */
export const rename = (
        target: AttributeNodePointer | ElementNodePointer | ProcessingInstructionNodePointer,
        newName: QName | null,
        domFacade: (DomFacade | null) | undefined,
        nodesFactory: (INodesFactory | null) | undefined,
        documentWriter: (IDocumentWriter | null) | undefined
) => {
        if (!nodesFactory) {
                nodesFactory = new DomBackedNodesFactory(target ? target.node : null);
        }

        let replacement;

        switch (domFacade.getNodeType(target)) {
                case NODE_TYPES.ELEMENT_NODE: {
                        const attributes = domFacade.getAllAttributes(
                                target.node as ConcreteElementNode | TinyElementNode
                        );
                        const childNodes = domFacade.getChildNodes(
                                target.node as ConcreteElementNode | TinyElementNode
                        );
                        const replacementNode = nodesFactory.createElementNS(
                                newName.namespaceURI,
                                newName.buildPrefixedName()
                        );
                        replacement = { node: replacementNode, graftAncestor: null };

                        attributes.forEach((attribute) => {
                                documentWriter.setAttributeNS(
                                        replacementNode,
                                        attribute.namespaceURI,
                                        attribute.nodeName,
                                        attribute.value
                                );
                        });
                        childNodes.forEach((childNode) => {
                                documentWriter.insertBefore(replacementNode, childNode, null);
                        });
                        break;
                }
                case NODE_TYPES.ATTRIBUTE_NODE: {
                        const replacementAttr = nodesFactory.createAttributeNS(
                                newName.namespaceURI,
                                newName.buildPrefixedName()
                        );
                        replacementAttr.value = domFacade.getDataFromPointer(target as AttributeNodePointer);
                        replacement = { node: replacementAttr, graftAncestor: null };
                        break;
                }
                case NODE_TYPES.PROCESSING_INSTRUCTION_NODE: {
                        replacement = {
                                node: nodesFactory.createProcessingInstruction(
                                        newName.buildPrefixedName(),
                                        domFacade.getDataFromPointer(target as ProcessingInstructionNodePointer)
                                ),
                                graftAncestor: null,
                        };
                        break;
                }
        }

        if (!domFacade.getParentNodePointer(target)) {
                throw new Error('Not supported: renaming detached nodes.');
        }

        replaceNode(target, [replacement], domFacade, documentWriter);
};

/**
 * Replaces the existing children of the element node $target by the optional text node $text. The attributes of $target are not affected.
 *
 * @param  target          The target to replace.
 * @param  text            The replacement.
 * @param  domFacade       The domFacade (or DomFacade like interface) for retrieving relations.
 * @param  documentWriter  The documentWriter for writing changes.
 */
export const replaceElementContent = (
        target: ElementNodePointer | DocumentNodePointer,
        text: NodePointer | null,
        domFacade: (DomFacade | null) | undefined,
        documentWriter: (IDocumentWriter | null) | undefined
) => {
        domFacade
                .getChildNodes(target.node)
                .forEach((child) => documentWriter.removeChild(target.node, child));
        if (text) {
                documentWriter.insertBefore(target.node, text.node, null);
        }
};

/**
 * Replaces $target with $replacement.
 *
 * @param  target          The target to replace.
 * @param  replacement     The replacement.
 * @param  domFacade       The domFacade (or DomFacade like interface) for retrieving relations.
 * @param  documentWriter  The documentWriter for writing changes.
 */
export const replaceNode = (
        target: AttributeNodePointer | ChildNodePointer,
        replacement: (AttributeNodePointer | ChildNodePointer)[],
        domFacade: (DomFacade | null) | undefined,
        documentWriter: (IDocumentWriter | null) | undefined
) => {
        // The parent must exist or an error has been raised.
        const parent = domFacade.getParentNodePointer(target);
        const targetNodeType = domFacade.getNodeType(target);

        if (targetNodeType === NODE_TYPES.ATTRIBUTE_NODE) {
                const attrTarget = target as AttributeNodePointer;
                // All replacement must consist of attribute nodes.
                if (
                        replacement.some(
                                (candidate) => domFacade.getNodeType(candidate) !== NODE_TYPES.ATTRIBUTE_NODE
                        )
                ) {
                        throw new Error(
                                'Constraint "If $target is an attribute node, $replacement must consist of zero or more attribute nodes." failed.'
                        );
                }

                const element: Element = parent ? (parent.node as Element) : null;

                documentWriter.removeAttributeNS(
                        element,
                        domFacade.getNamespaceURI(attrTarget),
                        domFacade.getLocalName(attrTarget)
                );
                replacement.forEach((attr: AttributeNodePointer) => {
                        const attrLocalName = domFacade.getLocalName(attr);
                        const attrNamespace = domFacade.getNamespaceURI(attr);
                        if (
                                hasAttribute(parent as ElementNodePointer, attrLocalName, attrNamespace, domFacade)
                        ) {
                                throw errXUDY0021(
                                        `An attribute ${
                                                attrNamespace ? `Q{${attrNamespace}}${attrLocalName}` : attrLocalName
                                        } already exists.`
                                );
                        }
                        documentWriter.setAttributeNS(
                                element,
                                attrNamespace,
                                attrLocalName,
                                domFacade.getDataFromPointer(attr)
                        );
                });
        }

        if (
                targetNodeType === NODE_TYPES.ELEMENT_NODE ||
                targetNodeType === NODE_TYPES.TEXT_NODE ||
                targetNodeType === NODE_TYPES.COMMENT_NODE ||
                targetNodeType === NODE_TYPES.PROCESSING_INSTRUCTION_NODE
        ) {
                const followingPointer = domFacade.getNextSiblingPointer(target as ChildNodePointer);
                const following = followingPointer ? followingPointer.node : null;
                documentWriter.removeChild(parent.node as Document | Element, target.node);
                replacement.forEach((newNode) => {
                        documentWriter.insertBefore(parent.node as Document | Element, newNode.node, following);
                });
        }
};

/**
 * Replaces the string value of $target with $string-value.
 *
 * @param  target          The target to replace.
 * @param  stringValue     The replacement.
 * @param  domFacade       The domFacade (or DomFacade like interface) for retrieving relations.
 * @param  documentWriter  The documentWriter for writing changes.
 */
export const replaceValue = (
        target: ElementNodePointer | AttributeNodePointer,
        stringValue: string,
        domFacade: (DomFacade | null) | undefined,
        documentWriter: (IDocumentWriter | null) | undefined
) => {
        if (domFacade.getNodeType(target) === NODE_TYPES.ATTRIBUTE_NODE) {
                const element = domFacade.getParentNodePointer(target) as ElementNodePointer;
                if (element) {
                        documentWriter.setAttributeNS(
                                element.node,
                                domFacade.getNamespaceURI(target),
                                domFacade.getLocalName(target),
                                stringValue
                        );
                } else {
                        (target.node as Attr).value = stringValue;
                }
        } else {
                documentWriter.setData(target.node, stringValue);
        }
};

1	import IDocumentWriter from '../../documentWriter/IDocumentWriter';
2	import {
3	AttributeNodePointer,
4	ChildNodePointer,
5	DocumentNodePointer,
6	ElementNodePointer,
7	NodePointer,
8	ProcessingInstructionNodePointer,
9	TinyElementNode,
10	} from '../../domClone/Pointer';
11	import { ConcreteElementNode, NODE_TYPES } from '../../domFacade/ConcreteNode';
12	import DomFacade from '../../domFacade/DomFacade';
13	import DomBackedNodesFactory from '../../nodesFactory/DomBackedNodesFactory';	9✔
14	import INodesFactory from '../../nodesFactory/INodesFactory';
15	import { Attr, Document, Element } from '../../types/Types';
16	import QName from '../dataTypes/valueTypes/QName';
17	import { errXUDY0021 } from './XQueryUpdateFacilityErrors';	9✔
18
19	function hasAttribute(
20	target: ElementNodePointer,
21	localName: string,
22	namespace: string,
23	domFacade: DomFacade
24	): boolean {
25	return domFacade	372✔
26	.getAllAttributePointers(target, `name-${localName}`)
27	.some(
28	(attr) =>
29	domFacade.getLocalName(attr) === localName &&	105✔
30	domFacade.getNamespaceURI(attr) === namespace
31	);
32	}
33
34	/**
35	* Deletes $target.
36	*
37	* @param target The target to delete.
38	* @param domFacade The domFacade (or DomFacade like interface) for retrieving relations.
39	* @param documentWriter The documentWriter for writing changes.
40	*/
41	export const deletePu = (	9✔
42	target: AttributeNodePointer \| ChildNodePointer,
43	domFacade: (DomFacade \| null) \| undefined,
44	documentWriter: (IDocumentWriter \| null) \| undefined
45	) => {
46	const parentPointer = domFacade.getParentNodePointer(target);	1,197✔
47	const parent = parentPointer ? parentPointer.node : null;	1,197✔
48	if (parent) {	1,197✔
49	if (domFacade.getNodeType(target) === NODE_TYPES.ATTRIBUTE_NODE) {	1,119✔
50	documentWriter.removeAttributeNS(	81✔
51	parent as Element,
52	domFacade.getNamespaceURI(target as AttributeNodePointer),
53	domFacade.getLocalName(target as AttributeNodePointer)
54	);
55	} else {
56	documentWriter.removeChild(parent as Document \| Element, target.node);	1,038✔
57	}
58	}
59	};
60
61	/**
62	* Inserts $content immediately after $target.
63	*
64	* @param target The target to insert after.
65	* @param content The content.
66	* @param domFacade The domFacade (or DomFacade like interface) for retrieving relations.
67	* @param documentWriter The documentWriter for writing changes.
68	*/
69	export const insertAfter = (	9✔
70	target: ChildNodePointer,
71	content: NodePointer[],
72	domFacade: (DomFacade \| null) \| undefined,
73	documentWriter: (IDocumentWriter \| null) \| undefined
74	) => {
75	// The parent must exist or an error has been raised.
76	const parent = domFacade.getParentNodePointer(target).node;	135✔
77	const nextSiblingPointer = domFacade.getNextSiblingPointer(target);	135✔
78	const nextSibling = nextSiblingPointer ? nextSiblingPointer.node : null;	135✔
79
80	content.forEach((pointer) => {	135✔
81	documentWriter.insertBefore(parent as Element, pointer.node, nextSibling);	183✔
82	});
83	};
84
85	/**
86	* Inserts $content immediately before $target.
87	*
88	* @param target The target to insert before.
89	* @param content The content.
90	* @param domFacade The domFacade (or DomFacade like interface) for retrieving relations.
91	* @param documentWriter The documentWriter for writing changes.
92	*/
93	export const insertBefore = (	9✔
94	target: ChildNodePointer,
95	content: NodePointer[],
96	domFacade: (DomFacade \| null) \| undefined,
97	documentWriter: (IDocumentWriter \| null) \| undefined
98	) => {
99	// The parent must exist or an error has been raised.
100	const parent = domFacade.getParentNodePointer(target).node;	138✔
101
102	content.forEach((pointer) => {	138✔
103	documentWriter.insertBefore(parent as Element, pointer.node, target.node);	192✔
104	});
105	};
106
107	/**
108	* Inserts $content as the children of $target, in an implementation-dependent position.
109	*
110	* @param target The target to insert into.
111	* @param content The content.
112	* @param documentWriter The documentWriter for writing changes.
113	*/
114	export const insertInto = (	9✔
115	target: ElementNodePointer \| DocumentNodePointer,
116	content: NodePointer[],
117	documentWriter: (IDocumentWriter \| null) \| undefined
118	) => {
119	insertIntoAsLast(target, content, documentWriter);	165✔
120	};
121
122	/**
123	* Inserts $content as the first children of $target.
124	*
125	* @param target The target to insert into.
126	* @param content The content.
127	* @param domFacade The domFacade (or DomFacade like interface) for retrieving relations.
128	* @param documentWriter The documentWriter for writing changes.
129	*/
130	export const insertIntoAsFirst = (	9✔
131	target: ElementNodePointer \| DocumentNodePointer,
132	content: NodePointer[],
133	domFacade: (DomFacade \| null) \| undefined,
134	documentWriter: (IDocumentWriter \| null) \| undefined
135	) => {
136	const firstChildPointer = domFacade.getFirstChildPointer(target);	84✔
137	const firstChild = firstChildPointer ? firstChildPointer.node : null;	84!
138	content.forEach((pointer) => {	84✔
139	documentWriter.insertBefore(target.node, pointer.node, firstChild);	96✔
140	});
141	};
142
143	/**
144	* Inserts $content as the last children of $target.
145	*
146	* @param target The target to insert into.
147	* @param content The content.
148	* @param documentWriter The documentWriter for writing changes.
149	*/
150	export const insertIntoAsLast = (	9✔
151	target: ElementNodePointer \| DocumentNodePointer,
152	content: NodePointer[],
153	documentWriter: (IDocumentWriter \| null) \| undefined
154	) => {
155	content.forEach((pointer) => {	273✔
156	documentWriter.insertBefore(target.node, pointer.node, null);	297✔
157	});
158	};
159
160	/**
161	* Inserts $content as attributes of $target.
162	*
163	* @param target The target to insert into.
164	* @param content The content.
165	* @param domFacade The domFacade (or DomFacade like interface) for retrieving relations.
166	* @param documentWriter The documentWriter for writing changes.
167	*/
168	export const insertAttributes = (	9✔
169	target: ElementNodePointer,
170	content: AttributeNodePointer[],
171	domFacade: (DomFacade \| null) \| undefined,
172	documentWriter: (IDocumentWriter \| null) \| undefined
173	) => {
174	content.forEach((attributeNodePointer) => {	177✔
175	const attrLocalName = domFacade.getLocalName(attributeNodePointer);	219✔
176	const attrNamespace = domFacade.getNamespaceURI(attributeNodePointer);	219✔
177	if (hasAttribute(target, attrLocalName, attrNamespace, domFacade)) {	219✔
178	throw errXUDY0021(	63✔
179	`An attribute ${
180	attrNamespace ? `Q{${attrNamespace}}${attrLocalName}` : attrLocalName	63✔
181	} already exists.`
182	);
183	}
184	documentWriter.setAttributeNS(	156✔
185	target.node,
186	attrNamespace,
187	attrLocalName,
188	domFacade.getDataFromPointer(attributeNodePointer)
189	);
190	});
191	};
192
193	/**
194	* Changes the node-name of $target to $newName.
195	*
196	* @param target The target to replace.
197	* @param newName The new name.
198	* @param domFacade The domFacade (or DomFacade like interface) for retrieving relations.
199	* @param nodesFactory The nodesFactory for creating nodes.
200	* @param documentWriter The documentWriter for writing changes.
201	*/
202	export const rename = (	9✔
203	target: AttributeNodePointer \| ElementNodePointer \| ProcessingInstructionNodePointer,
204	newName: QName \| null,
205	domFacade: (DomFacade \| null) \| undefined,
206	nodesFactory: (INodesFactory \| null) \| undefined,
207	documentWriter: (IDocumentWriter \| null) \| undefined
208	) => {
209	if (!nodesFactory) {	660✔
210	nodesFactory = new DomBackedNodesFactory(target ? target.node : null);	273!
211	}
212
213	let replacement;
214
215	switch (domFacade.getNodeType(target)) {	660✔
216	case NODE_TYPES.ELEMENT_NODE: {
217	const attributes = domFacade.getAllAttributes(	606✔
218	target.node as ConcreteElementNode \| TinyElementNode
219	);
220	const childNodes = domFacade.getChildNodes(	606✔
221	target.node as ConcreteElementNode \| TinyElementNode
222	);
223	const replacementNode = nodesFactory.createElementNS(	606✔
224	newName.namespaceURI,
225	newName.buildPrefixedName()
226	);
227	replacement = { node: replacementNode, graftAncestor: null };	606✔
228
229	attributes.forEach((attribute) => {	606✔
230	documentWriter.setAttributeNS(	348✔
231	replacementNode,
232	attribute.namespaceURI,
233	attribute.nodeName,
234	attribute.value
235	);
236	});
237	childNodes.forEach((childNode) => {	606✔
238	documentWriter.insertBefore(replacementNode, childNode, null);	1,734✔
239	});
240	break;	606✔
241	}
242	case NODE_TYPES.ATTRIBUTE_NODE: {
243	const replacementAttr = nodesFactory.createAttributeNS(	24✔
244	newName.namespaceURI,
245	newName.buildPrefixedName()
246	);
247	replacementAttr.value = domFacade.getDataFromPointer(target as AttributeNodePointer);	24✔
248	replacement = { node: replacementAttr, graftAncestor: null };	24✔
249	break;	24✔
250	}
251	case NODE_TYPES.PROCESSING_INSTRUCTION_NODE: {
252	replacement = {	30✔
253	node: nodesFactory.createProcessingInstruction(
254	newName.buildPrefixedName(),
255	domFacade.getDataFromPointer(target as ProcessingInstructionNodePointer)
256	),
257	graftAncestor: null,
258	};
259	break;	30✔
260	}
261	}
262
263	if (!domFacade.getParentNodePointer(target)) {	660!
UNCOV 264	throw new Error('Not supported: renaming detached nodes.');	×
265	}
266
267	replaceNode(target, [replacement], domFacade, documentWriter);	660✔
268	};
269
270	/**
271	* Replaces the existing children of the element node $target by the optional text node $text. The attributes of $target are not affected.
272	*
273	* @param target The target to replace.
274	* @param text The replacement.
275	* @param domFacade The domFacade (or DomFacade like interface) for retrieving relations.
276	* @param documentWriter The documentWriter for writing changes.
277	*/
278	export const replaceElementContent = (	9✔
279	target: ElementNodePointer \| DocumentNodePointer,
280	text: NodePointer \| null,
281	domFacade: (DomFacade \| null) \| undefined,
282	documentWriter: (IDocumentWriter \| null) \| undefined
283	) => {
284	domFacade	231✔
285	.getChildNodes(target.node)
286	.forEach((child) => documentWriter.removeChild(target.node, child));	528✔
287	if (text) {	231✔
288	documentWriter.insertBefore(target.node, text.node, null);	219✔
289	}
290	};
291
292	/**
293	* Replaces $target with $replacement.
294	*
295	* @param target The target to replace.
296	* @param replacement The replacement.
297	* @param domFacade The domFacade (or DomFacade like interface) for retrieving relations.
298	* @param documentWriter The documentWriter for writing changes.
299	*/
300	export const replaceNode = (	9✔
301	target: AttributeNodePointer \| ChildNodePointer,
302	replacement: (AttributeNodePointer \| ChildNodePointer)[],
303	domFacade: (DomFacade \| null) \| undefined,
304	documentWriter: (IDocumentWriter \| null) \| undefined
305	) => {
306	// The parent must exist or an error has been raised.
307	const parent = domFacade.getParentNodePointer(target);	867✔
308	const targetNodeType = domFacade.getNodeType(target);	867✔
309
310	if (targetNodeType === NODE_TYPES.ATTRIBUTE_NODE) {	867✔
311	const attrTarget = target as AttributeNodePointer;	117✔
312	// All replacement must consist of attribute nodes.
313	if (	117!
314	replacement.some(
315	(candidate) => domFacade.getNodeType(candidate) !== NODE_TYPES.ATTRIBUTE_NODE	153✔
316	)
317	) {
UNCOV 318	throw new Error(	×
319	'Constraint "If $target is an attribute node, $replacement must consist of zero or more attribute nodes." failed.'
320	);
321	}
322
323	const element: Element = parent ? (parent.node as Element) : null;	117!
324
325	documentWriter.removeAttributeNS(	117✔
326	element,
327	domFacade.getNamespaceURI(attrTarget),
328	domFacade.getLocalName(attrTarget)
329	);
330	replacement.forEach((attr: AttributeNodePointer) => {	117✔
331	const attrLocalName = domFacade.getLocalName(attr);	153✔
332	const attrNamespace = domFacade.getNamespaceURI(attr);	153✔
333	if (	153✔
334	hasAttribute(parent as ElementNodePointer, attrLocalName, attrNamespace, domFacade)
335	) {
336	throw errXUDY0021(	39✔
337	`An attribute ${
338	attrNamespace ? `Q{${attrNamespace}}${attrLocalName}` : attrLocalName	39✔
339	} already exists.`
340	);
341	}
342	documentWriter.setAttributeNS(	114✔
343	element,
344	attrNamespace,
345	attrLocalName,
346	domFacade.getDataFromPointer(attr)
347	);
348	});
349	}
350
351	if (	828✔
352	targetNodeType === NODE_TYPES.ELEMENT_NODE \|\|	1,200✔
353	targetNodeType === NODE_TYPES.TEXT_NODE \|\|
354	targetNodeType === NODE_TYPES.COMMENT_NODE \|\|
355	targetNodeType === NODE_TYPES.PROCESSING_INSTRUCTION_NODE
356	) {
357	const followingPointer = domFacade.getNextSiblingPointer(target as ChildNodePointer);	750✔
358	const following = followingPointer ? followingPointer.node : null;	750✔
359	documentWriter.removeChild(parent.node as Document \| Element, target.node);	750✔
360	replacement.forEach((newNode) => {	750✔
361	documentWriter.insertBefore(parent.node as Document \| Element, newNode.node, following);	768✔
362	});
363	}
364	};
365
366	/**
367	* Replaces the string value of $target with $string-value.
368	*
369	* @param target The target to replace.
370	* @param stringValue The replacement.
371	* @param domFacade The domFacade (or DomFacade like interface) for retrieving relations.
372	* @param documentWriter The documentWriter for writing changes.
373	*/
374	export const replaceValue = (	9✔
375	target: ElementNodePointer \| AttributeNodePointer,
376	stringValue: string,
377	domFacade: (DomFacade \| null) \| undefined,
378	documentWriter: (IDocumentWriter \| null) \| undefined
379	) => {
380	if (domFacade.getNodeType(target) === NODE_TYPES.ATTRIBUTE_NODE) {	312✔
381	const element = domFacade.getParentNodePointer(target) as ElementNodePointer;	123✔
382	if (element) {	123✔
383	documentWriter.setAttributeNS(	117✔
384	element.node,
385	domFacade.getNamespaceURI(target),
386	domFacade.getLocalName(target),
387	stringValue
388	);
389	} else {
390	(target.node as Attr).value = stringValue;	6✔
391	}
392	} else {
393	documentWriter.setData(target.node, stringValue);	189✔
394	}
395	};

FontoXML / fontoxpath / 5078784284

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous