/** * Finds the first child node with given node name. */ public Node findChildNodeWithName(final String name) { if (childNodes == null) { return null; } for (final Node childNode : childNodes) { if (childNode.getNodeName().equals(name)) { return childNode; } } return null; }
/** * Returns <code>true</code> if parent node is one of the table elements. */ protected boolean isParentNodeOneOfFosterTableElements(final Node parentNode) { if (parentNode == null) { return false; } if (parentNode.getNodeName() == null) { return false; } String nodeName = parentNode.getNodeName().toLowerCase(); return StringUtil.equalsOne(nodeName, FOSTER_TABLE_ELEMENTS) != -1; }
@Override public boolean match(final Node node) { String name = node.getNodeName(); if (name == null) { return false; } if (name.length() != 2) { return false; } char c1 = name.charAt(0); if (c1 != 'h' && c1 != 'H') { return false; } int c2 = name.charAt(1) - '0'; return c2 >= 1 && c2 <= 6; } }
/** * Initializes siblings elements of the same name. */ protected void initSiblingNames() { if (siblingNameIndex == -1) { List<Node> siblings = parentNode.childNodes; int index = 0; for (int i = 0, siblingsSize = siblings.size(); i < siblingsSize; i++) { Node sibling = siblings.get(i); if (sibling.siblingNameIndex == -1 && nodeType == NodeType.ELEMENT && nodeName.equals(sibling.getNodeName())) { sibling.siblingNameIndex = index++; } } } }
/** * Returns <code>true</code> if given node is a table element. */ protected boolean isTableElement(final Node node) { if (node.getNodeType() != Node.NodeType.ELEMENT) { return false; } String elementName = node.getNodeName().toLowerCase(); return elementName.equals("table"); }
/** * Returns this node's previous sibling element with the same name. */ public Node getPreviousSiblingName() { if (nodeName == null) { return null; } initSiblingNames(); int index = siblingNameIndex -1; for (int i = siblingIndex; i >= 0; i--) { Node sibling = parentNode.childNodes.get(i); if ((index == sibling.siblingNameIndex) && nodeName.equals(sibling.getNodeName())) { return sibling; } } return null; }
/** * Matches element to css selector. All non-element types are ignored. */ protected boolean matchElement(final Node node) { if (node.getNodeType() != Node.NodeType.ELEMENT) { return false; } String element = getElement(); String nodeName = node.getNodeName(); return element.equals(StringPool.STAR) || element.equals(nodeName); }
/** * Returns first child <b>element</b> with given name or * <code>null</code> if no such children exist. */ public Element getFirstChildElement(final String elementName) { if (childNodes == null) { return null; } for (int i = 0, childNodesSize = childNodes.size(); i < childNodesSize; i++) { Node child = childNodes.get(i); if (child.getNodeType() == NodeType.ELEMENT && elementName.equals(child.getNodeName())) { child.initSiblingNames(); return (Element) child; } } return null; }
/** * Returns CSS path to this node from document root. */ public String getCssPath() { StringBuilder path = new StringBuilder(); Node node = this; while (node != null) { String nodeName = node.getNodeName(); if (nodeName != null) { StringBuilder sb = new StringBuilder(); sb.append(' ').append(nodeName); String id = node.getAttribute("id"); if (id != null) { sb.append('#').append(id); } path.insert(0, sb); } node = node.getParentNode(); } if (path.charAt(0) == ' ') { return path.substring(1); } return path.toString(); }
/** * Finds the last table in stack of open elements. */ protected Element findLastTable(final Node node) { Node tableNode = node; while (tableNode != null) { if (tableNode.getNodeType() == Node.NodeType.ELEMENT) { String tableNodeName = tableNode.getNodeName().toLowerCase(); if (tableNodeName.equals("table")) { break; } } tableNode = tableNode.getParentNode(); } return (Element) tableNode; }
/** * Returns last child <b>element</b> with given name or * <code>null</code> if no such child node exist. */ public Element getLastChildElement(final String elementName) { if (childNodes == null) { return null; } int from = childNodes.size() - 1; for (int i = from; i >= 0; i--) { Node child = childNodes.get(i); if (child.getNodeType() == NodeType.ELEMENT && elementName.equals(child.getNodeName())) { child.initSiblingNames(); return (Element) child; } } return null; }
@Override public boolean match(Node node, Object expression) { Integer size = (Integer) expression; return node.getNodeName().length() == size.intValue(); }
/** * Returns this node's next <b>element</b> with the same name. */ public Node getNextSiblingName() { if (nodeName == null) { return null; } initSiblingNames(); int index = siblingNameIndex + 1; int max = parentNode.getChildNodesCount(); for (int i = siblingIndex + 1; i < max; i++) { Node sibling = parentNode.childNodes.get(i); if ((index == sibling.siblingNameIndex) && nodeName.equals(sibling.getNodeName())) { return sibling; } } return null; }
/** * Renders node name. */ protected String resolveNodeName(final Node node) { switch (tagCase) { case DEFAULT: return node.getNodeName(); case RAW: return node.getNodeRawName(); case LOWERCASE: return node.getNodeRawName().toLowerCase(); case UPPERCASE: return node.getNodeRawName().toUpperCase(); } return null; }
/** * Finds matching parent open tag or <code>null</code> if not found. */ protected Node findMatchingParentOpenTag(String tagName) { Node parent = parentNode; if (!rootNode.config.isCaseSensitive()) { tagName = tagName.toLowerCase(); } while (parent != null) { String parentNodeName = parent.getNodeName(); if (parentNodeName != null) { if (!rootNode.config.isCaseSensitive()) { parentNodeName = parentNodeName.toLowerCase(); } } if (tagName.equals(parentNodeName)) { return parent; } parent = parent.getParentNode(); } return null; }
@Override public boolean match(final Node node, final PseudoFunctionExpression expression) { Node child = node.getParentNode().getLastChildElement(node.getNodeName()); int value = child.getSiblingNameIndex() + 1 - node.getSiblingNameIndex(); return expression.match(value); } }
@Test void testTags() throws IOException { NodeSelector nodeSelector = createNodeFilter(); List<Node> nodes = nodeSelector.select("div"); assertEquals(5, nodes.size()); nodes = nodeSelector.select("body"); assertEquals(1, nodes.size()); assertEquals("body", nodes.get(0).getNodeName()); nodes = nodeSelector.select("p"); assertEquals(4, nodes.size()); }
@Test void testMoreTags() throws IOException { NodeSelector nodeSelector = createNodeFilter(); List<Node> nodes = nodeSelector.select("div b"); assertEquals(1, nodes.size()); assertEquals("b", nodes.get(0).getNodeName()); assertEquals("p", nodes.get(0).getParentNode().getNodeName()); nodes = nodeSelector.select("p b"); assertEquals(4, nodes.size()); nodes = nodeSelector.select("div div"); assertEquals(3, nodes.size()); nodes = nodeSelector.select("div div div"); assertEquals(2, nodes.size()); nodes = nodeSelector.select("* div div div"); assertEquals(2, nodes.size()); }
@Test void testClassWithTabs() throws IOException { File file = new File(testDataRoot, "class-tabs.html"); String htmlContent = FileUtil.readString(file); Document document = new LagartoDOMBuilder().parse(htmlContent); List<Node> nodes = new NodeSelector(document).select(".hey"); assertEquals(1, nodes.size()); Node n = nodes.get(0); assertEquals("div", n.getNodeName()); assertEquals("jodd", n.getAttribute("id")); }
@Test void test233() { String html = "<div><span>name</span>value</div>"; Jerry $ = Jerry.jerry(html); assertEquals("namevalue", $.text()); assertEquals(1, $.children().size()); Node div = $.children().get(0); assertEquals("div", div.getNodeName()); assertEquals(2, div.getChildNodesCount()); assertEquals("value", div.getChild(1).getNodeValue()); }