#4039

Committed 07 May 2024 01:09PM UTC coverage: 48.864% (+0.02%) from 48.84%

Build # #4039

Build Type

push

github

Committed by

oowekyala

Commit Message

Merge branch 'pr/4969'

Ref #4969

Run Details

32603 of 72996 branches covered (44.66%)

Branch coverage included in aggregate %.

13 of 16 new or added lines in 4 files covered. (81.25%)

10 existing lines in 2 files now uncovered.

68542 of 133998 relevant lines covered (51.15%)

0.51 hits per line

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

43.24

/pmd-core/src/main/java/net/sourceforge/pmd/lang/rule/xpath/internal/AstElementNode.java

/*
 * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
 */

package net.sourceforge.pmd.lang.rule.xpath.internal;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import org.apache.commons.lang3.mutable.MutableInt;
import org.checkerframework.checker.nullness.qual.Nullable;

import net.sourceforge.pmd.lang.ast.Node;
import net.sourceforge.pmd.lang.ast.RootNode;
import net.sourceforge.pmd.lang.rule.xpath.Attribute;
import net.sourceforge.pmd.lang.rule.xpath.CommentNode;
import net.sourceforge.pmd.lang.rule.xpath.TextNode;
import net.sourceforge.pmd.util.CollectionUtil;

import net.sf.saxon.Configuration;
import net.sf.saxon.om.NamespaceUri;
import net.sf.saxon.om.NodeInfo;
import net.sf.saxon.pattern.NameTest;
import net.sf.saxon.pattern.NodeTest;
import net.sf.saxon.tree.iter.AxisIterator;
import net.sf.saxon.tree.iter.EmptyIterator;
import net.sf.saxon.tree.iter.LookaheadIterator;
import net.sf.saxon.tree.iter.SingleNodeIterator;
import net.sf.saxon.tree.util.Navigator;
import net.sf.saxon.tree.wrapper.SiblingCountingNode;
import net.sf.saxon.type.Type;


/**
 * A wrapper for Saxon around a Node. Note: the {@link RootNode} of a tree
 * corresponds to both a document node and an element node that is its child.
 */
public final class AstElementNode extends BaseNodeInfo implements SiblingCountingNode, AstNodeOwner {

    private final Node wrappedNode;
    /** The index of the node in the tree according to document order */
    private final int id;

    private final List<AstElementNode> children;
    private @Nullable Map<String, AstAttributeNode> attributes;
    private @Nullable Map<String, Attribute> lightAttributes;


    AstElementNode(AstTreeInfo document,
                   MutableInt idGenerator,
                   BaseNodeInfo parent,
                   Node wrappedNode,
                   Configuration configuration) {
        super(determineType(wrappedNode), configuration.getNamePool(), wrappedNode.getXPathNodeName(), parent);

        this.treeInfo = document;
        this.wrappedNode = wrappedNode;
        this.id = idGenerator.getAndIncrement();

        this.children = new ArrayList<>(wrappedNode.getNumChildren());

        for (int i = 0; i < wrappedNode.getNumChildren(); i++) {
            children.add(new AstElementNode(document, idGenerator, this, wrappedNode.getChild(i), configuration));
        }
    }

    private static int determineType(Node node) {
        // As of PMD 7, only the HTML module uses these interfaces
        if (node instanceof TextNode) {
            return Type.TEXT;
        } else if (node instanceof CommentNode) {
            return Type.COMMENT;
        }
        return Type.ELEMENT;
    }

    public Map<String, AstAttributeNode> makeAttributes(Node wrappedNode) {
        Map<String, AstAttributeNode> atts = new HashMap<>();
        Iterator<Attribute> it = wrappedNode.getXPathAttributesIterator();

        int attrIdx = 0;
        while (it.hasNext()) {
            Attribute next = it.next();
            atts.put(next.getName(), new AstAttributeNode(this, next, attrIdx++));
        }

        return atts;
    }

    public Map<String, AstAttributeNode> getAttributes() {
        if (attributes == null) {
            attributes = makeAttributes(getUnderlyingNode());
        }
        return attributes;
    }

    public Map<String, Attribute> getLightAttributes() {
        if (lightAttributes == null) {
            lightAttributes = new HashMap<>();
            getUnderlyingNode().getXPathAttributesIterator()
                               .forEachRemaining(it -> lightAttributes.put(it.getName(), it));
        }
        return lightAttributes;
    }

    @Override
    public boolean hasChildNodes() {
        return !children.isEmpty();
    }

    @Override
    List<AstElementNode> getChildren() {
        return children;
    }

    @Override
    public Node getUnderlyingNode() {
        return wrappedNode;
    }

    @Override
    public int getColumnNumber() {
        return wrappedNode.getBeginColumn();
    }

    @Override
    public int getSiblingPosition() {
        BaseNodeInfo parent = getParent();
        return !(parent instanceof AstElementNode) ? 0
                                                   : id - ((AstElementNode) parent).id;
    }

    @Override
    public int compareOrder(NodeInfo other) {
        if (other instanceof AstElementNode) {
            return Integer.compare(this.id, ((AstElementNode) other).id);
        } else if (other instanceof SiblingCountingNode) {
            return Navigator.compareOrder(this, (SiblingCountingNode) other);
        }
        throw new UnsupportedOperationException();
    }

    @Override
    protected AxisIterator iterateAttributes(NodeTest predicate) {
        if (predicate instanceof NameTest) {
            String local = ((NameTest) predicate).getLocalPart();
            return SingleNodeIterator.makeIterator(getAttributes().get(local));
        }

        return filter(predicate, new IteratorAdapter(getAttributes().values().iterator()));
    }

    @Override
    protected AxisIterator iterateChildren(NodeTest nodeTest) {
        return filter(nodeTest, iterateList(children));
    }

    @Override // this excludes self
    protected AxisIterator iterateSiblings(NodeTest nodeTest, boolean forwards) {
        if (parent == null) {
            return EmptyIterator.ofNodes();
        }

        List<? extends NodeInfo> siblingsList =
            forwards ? CollectionUtil.drop(parent.getChildren(), wrappedNode.getIndexInParent() + 1)
                     : CollectionUtil.take(parent.getChildren(), wrappedNode.getIndexInParent());

        return filter(nodeTest, iterateList(siblingsList, forwards));
    }

    @Override
    public String getAttributeValue(NamespaceUri uri, String local) {
        Attribute attribute = getLightAttributes().get(local);
        if (attribute != null) {
            getTreeInfo().getLogger().recordUsageOf(attribute);
            return attribute.getStringValue();
        }
        return null;
    }


    @Override
    public int getLineNumber() {
        return wrappedNode.getBeginLine();
    }


    @Override
    public NodeInfo getRoot() {
        return getTreeInfo().getRootNode();
    }


    @Override
    public void generateId(StringBuilder buffer) {
        buffer.append(id);
    }

    @Override
    public String getLocalPart() {
        return wrappedNode.getXPathNodeName();
    }

    @Override
    public String getStringValue() {
        Node node = getUnderlyingNode();
        if (node instanceof TextNode) {
            return ((TextNode) node).getText();
        }
        if (node instanceof CommentNode) {
            return ((CommentNode) node).getData();
        }

        // https://www.w3.org/TR/xpath-datamodel-31/#ElementNode
        // The string-value property of an Element Node must be the
        // concatenation of the string-values of all its Text Node
        // descendants in document order or, if the element has no such
        // descendants, the zero-length string.

        // Since we represent all our Nodes as elements, there are no
        // text nodes usually, except for HTML module - there we have
        // potentially text nodes
        return node.descendants(TextNode.class).toStream()
                .map(TextNode::getText)
                .collect(Collectors.joining(""));
    }

    @Override
    public String toString() {
        return "Wrapper[" + getLocalPart() + "]@" + hashCode();
    }



    private static class IteratorAdapter implements AxisIterator, LookaheadIterator {

        private final Iterator<? extends NodeInfo> it;

        IteratorAdapter(Iterator<? extends NodeInfo> it) {
            this.it = it;
        }

        @Override
        public boolean hasNext() {
            return it.hasNext();
        }

        @Override
        public NodeInfo next() {
            return it.hasNext() ? it.next() : null;
        }

        @Override
        public void close() {
            // nothing to do
        }

        @Override
        public boolean supportsHasNext() {
            return true;
        }
    }
}

1	/*
2	* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
3	*/
4
5	package net.sourceforge.pmd.lang.rule.xpath.internal;
6
7	import java.util.ArrayList;
8	import java.util.HashMap;
9	import java.util.Iterator;
10	import java.util.List;
11	import java.util.Map;
12	import java.util.stream.Collectors;
13
14	import org.apache.commons.lang3.mutable.MutableInt;
15	import org.checkerframework.checker.nullness.qual.Nullable;
16
17	import net.sourceforge.pmd.lang.ast.Node;
18	import net.sourceforge.pmd.lang.ast.RootNode;
19	import net.sourceforge.pmd.lang.rule.xpath.Attribute;
20	import net.sourceforge.pmd.lang.rule.xpath.CommentNode;
21	import net.sourceforge.pmd.lang.rule.xpath.TextNode;
22	import net.sourceforge.pmd.util.CollectionUtil;
23
24	import net.sf.saxon.Configuration;
25	import net.sf.saxon.om.NamespaceUri;
26	import net.sf.saxon.om.NodeInfo;
27	import net.sf.saxon.pattern.NameTest;
28	import net.sf.saxon.pattern.NodeTest;
29	import net.sf.saxon.tree.iter.AxisIterator;
30	import net.sf.saxon.tree.iter.EmptyIterator;
31	import net.sf.saxon.tree.iter.LookaheadIterator;
32	import net.sf.saxon.tree.iter.SingleNodeIterator;
33	import net.sf.saxon.tree.util.Navigator;
34	import net.sf.saxon.tree.wrapper.SiblingCountingNode;
35	import net.sf.saxon.type.Type;
36
37
38	/**
39	* A wrapper for Saxon around a Node. Note: the {@link RootNode} of a tree
40	* corresponds to both a document node and an element node that is its child.
41	*/
42	public final class AstElementNode extends BaseNodeInfo implements SiblingCountingNode, AstNodeOwner {
43
44	private final Node wrappedNode;
45	/** The index of the node in the tree according to document order */
46	private final int id;
47
48	private final List<AstElementNode> children;
49	private @Nullable Map<String, AstAttributeNode> attributes;
50	private @Nullable Map<String, Attribute> lightAttributes;
51
52
53	AstElementNode(AstTreeInfo document,
54	MutableInt idGenerator,
55	BaseNodeInfo parent,
56	Node wrappedNode,
57	Configuration configuration) {
58	super(determineType(wrappedNode), configuration.getNamePool(), wrappedNode.getXPathNodeName(), parent);	1✔
59
60	this.treeInfo = document;	1✔
61	this.wrappedNode = wrappedNode;	1✔
62	this.id = idGenerator.getAndIncrement();	1✔
63
64	this.children = new ArrayList<>(wrappedNode.getNumChildren());	1✔
65
66	for (int i = 0; i < wrappedNode.getNumChildren(); i++) {	1✔
67	children.add(new AstElementNode(document, idGenerator, this, wrappedNode.getChild(i), configuration));	1✔
68	}
69	}	1✔
70
71	private static int determineType(Node node) {
72	// As of PMD 7, only the HTML module uses these interfaces
73	if (node instanceof TextNode) {	1✔
74	return Type.TEXT;	1✔
75	} else if (node instanceof CommentNode) {	1✔
76	return Type.COMMENT;	1✔
77	}
78	return Type.ELEMENT;	1✔
79	}
80
81	public Map<String, AstAttributeNode> makeAttributes(Node wrappedNode) {
82	Map<String, AstAttributeNode> atts = new HashMap<>();	1✔
83	Iterator<Attribute> it = wrappedNode.getXPathAttributesIterator();	1✔
84
85	int attrIdx = 0;	1✔
86	while (it.hasNext()) {	1✔
87	Attribute next = it.next();	1✔
88	atts.put(next.getName(), new AstAttributeNode(this, next, attrIdx++));	1✔
89	}	1✔
90
91	return atts;	1✔
92	}
93
94	public Map<String, AstAttributeNode> getAttributes() {
95	if (attributes == null) {	1✔
96	attributes = makeAttributes(getUnderlyingNode());	1✔
97	}
98	return attributes;	1✔
99	}
100
101	public Map<String, Attribute> getLightAttributes() {
UNCOV 102	if (lightAttributes == null) {	×
UNCOV 103	lightAttributes = new HashMap<>();	×
UNCOV 104	getUnderlyingNode().getXPathAttributesIterator()	×
UNCOV 105	.forEachRemaining(it -> lightAttributes.put(it.getName(), it));	×
106	}
UNCOV 107	return lightAttributes;	×
108	}
109
110	@Override
111	public boolean hasChildNodes() {
112	return !children.isEmpty();	1✔
113	}
114
115	@Override
116	List<AstElementNode> getChildren() {
117	return children;	1✔
118	}
119
120	@Override
121	public Node getUnderlyingNode() {
122	return wrappedNode;	1✔
123	}
124
125	@Override
126	public int getColumnNumber() {
127	return wrappedNode.getBeginColumn();	×
128	}
129
130	@Override
131	public int getSiblingPosition() {
132	BaseNodeInfo parent = getParent();	×
133	return !(parent instanceof AstElementNode) ? 0	×
134	: id - ((AstElementNode) parent).id;	×
135	}
136
137	@Override
138	public int compareOrder(NodeInfo other) {
139	if (other instanceof AstElementNode) {	1!
140	return Integer.compare(this.id, ((AstElementNode) other).id);	1✔
141	} else if (other instanceof SiblingCountingNode) {	×
142	return Navigator.compareOrder(this, (SiblingCountingNode) other);	×
143	}
144	throw new UnsupportedOperationException();	×
145	}
146
147	@Override
148	protected AxisIterator iterateAttributes(NodeTest predicate) {
149	if (predicate instanceof NameTest) {	1!
150	String local = ((NameTest) predicate).getLocalPart();	1✔
151	return SingleNodeIterator.makeIterator(getAttributes().get(local));	1✔
152	}
153
154	return filter(predicate, new IteratorAdapter(getAttributes().values().iterator()));	×
155	}
156
157	@Override
158	protected AxisIterator iterateChildren(NodeTest nodeTest) {
159	return filter(nodeTest, iterateList(children));	1✔
160	}
161
162	@Override // this excludes self
163	protected AxisIterator iterateSiblings(NodeTest nodeTest, boolean forwards) {
164	if (parent == null) {	×
165	return EmptyIterator.ofNodes();	×
166	}
167
168	List<? extends NodeInfo> siblingsList =
169	forwards ? CollectionUtil.drop(parent.getChildren(), wrappedNode.getIndexInParent() + 1)	×
170	: CollectionUtil.take(parent.getChildren(), wrappedNode.getIndexInParent());	×
171
172	return filter(nodeTest, iterateList(siblingsList, forwards));	×
173	}
174
175	@Override
176	public String getAttributeValue(NamespaceUri uri, String local) {
UNCOV 177	Attribute attribute = getLightAttributes().get(local);	×
UNCOV 178	if (attribute != null) {	×
UNCOV 179	getTreeInfo().getLogger().recordUsageOf(attribute);	×
UNCOV 180	return attribute.getStringValue();	×
181	}
182	return null;	×
183	}
184
185
186	@Override
187	public int getLineNumber() {
188	return wrappedNode.getBeginLine();	×
189	}
190
191
192	@Override
193	public NodeInfo getRoot() {
194	return getTreeInfo().getRootNode();	1✔
195	}
196
197
198	@Override
199	public void generateId(StringBuilder buffer) {
200	buffer.append(id);	×
201	}	×
202
203	@Override
204	public String getLocalPart() {
205	return wrappedNode.getXPathNodeName();	×
206	}
207
208	@Override
209	public String getStringValue() {
210	Node node = getUnderlyingNode();	×
211	if (node instanceof TextNode) {	×
212	return ((TextNode) node).getText();	×
213	}
214	if (node instanceof CommentNode) {	×
215	return ((CommentNode) node).getData();	×
216	}
217
218	// https://www.w3.org/TR/xpath-datamodel-31/#ElementNode
219	// The string-value property of an Element Node must be the
220	// concatenation of the string-values of all its Text Node
221	// descendants in document order or, if the element has no such
222	// descendants, the zero-length string.
223
224	// Since we represent all our Nodes as elements, there are no
225	// text nodes usually, except for HTML module - there we have
226	// potentially text nodes
227	return node.descendants(TextNode.class).toStream()	×
228	.map(TextNode::getText)	×
229	.collect(Collectors.joining(""));	×
230	}
231
232	@Override
233	public String toString() {
234	return "Wrapper[" + getLocalPart() + "]@" + hashCode();	×
235	}
236
237
238
239	private static class IteratorAdapter implements AxisIterator, LookaheadIterator {
240
241	private final Iterator<? extends NodeInfo> it;
242
243	IteratorAdapter(Iterator<? extends NodeInfo> it) {	×
244	this.it = it;	×
245	}	×
246
247	@Override
248	public boolean hasNext() {
249	return it.hasNext();	×
250	}
251
252	@Override
253	public NodeInfo next() {
254	return it.hasNext() ? it.next() : null;	×
255	}
256
257	@Override
258	public void close() {
259	// nothing to do
260	}	×
261
262	@Override
263	public boolean supportsHasNext() {
264	return true;	×
265	}
266	}
267	}

pmd / pmd / #4039

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