iterator = inputSet.iterator();
+
+ while (iterator.hasNext()) {
+ Node inputNode = iterator.next();
+
+ if (!XMLUtils.isDescendantOrSelf(signatureElement, inputNode)) {
+ resultSet.add(inputNode);
+ }
+ }
+ return resultSet;
+ }
+
+ /**
+ * Method getStrFromNode
+ *
+ * @param xpathnode
+ * @return the string for the node.
+ */
+ public static String getStrFromNode(Node xpathnode) {
+ if (xpathnode.getNodeType() == Node.TEXT_NODE) {
+ // we iterate over all siblings of the context node because eventually,
+ // the text is "polluted" with pi's or comments
+ StringBuilder sb = new StringBuilder();
+
+ for (Node currentSibling = xpathnode.getParentNode().getFirstChild();
+ currentSibling != null;
+ currentSibling = currentSibling.getNextSibling()) {
+ if (currentSibling.getNodeType() == Node.TEXT_NODE) {
+ sb.append(((Text) currentSibling).getData());
+ }
+ }
+
+ return sb.toString();
+ } else if (xpathnode.getNodeType() == Node.ATTRIBUTE_NODE) {
+ return ((Attr) xpathnode).getNodeValue();
+ } else if (xpathnode.getNodeType() == Node.PROCESSING_INSTRUCTION_NODE) {
+ return ((ProcessingInstruction) xpathnode).getNodeValue();
+ }
+
+ return null;
+ }
+
+ /**
+ * Returns true if the descendantOrSelf is on the descendant-or-self axis
+ * of the context node.
+ *
+ * @param ctx
+ * @param descendantOrSelf
+ * @return true if the node is descendant
+ */
+ public static boolean isDescendantOrSelf(Node ctx, Node descendantOrSelf) {
+ if (ctx == descendantOrSelf) {
+ return true;
+ }
+
+ Node parent = descendantOrSelf;
+
+ while (true) {
+ if (parent == null) {
+ return false;
+ }
+
+ if (parent == ctx) {
+ return true;
+ }
+
+ if (parent.getNodeType() == Node.ATTRIBUTE_NODE) {
+ parent = ((Attr) parent).getOwnerElement();
+ } else {
+ parent = parent.getParentNode();
+ }
+ }
+ }
+
+ /**
+ * Returns the attribute value for the attribute with the specified name.
+ * Returns null if there is no such attribute, or
+ * the empty string if the attribute value is empty.
+ *
+ * This works around a limitation of the DOM
+ * Element.getAttributeNode method, which does not distinguish
+ * between an unspecified attribute and an attribute with a value of
+ * "" (it returns "" for both cases).
+ *
+ * @param elem the element containing the attribute
+ * @param name the name of the attribute
+ * @return the attribute value (may be null if unspecified)
+ */
+ public static String getAttributeValue(Element elem, String name) {
+ Attr attr = elem.getAttributeNodeNS(null, name);
+ return (attr == null) ? null : attr.getValue();
+ }
+
+ /**
+ * This method is a tree-search to help prevent against wrapping attacks. It checks that no
+ * two Elements have ID Attributes that match the "value" argument, if this is the case then
+ * "false" is returned. Note that a return value of "true" does not necessarily mean that
+ * a matching Element has been found, just that no wrapping attack has been detected.
+ */
+ public static boolean protectAgainstWrappingAttack(Node startNode, String value) {
+ Node startParent = startNode.getParentNode();
+ Node processedNode;
+ Element foundElement = null;
+
+ String id = value.trim();
+ if (id.charAt(0) == '#') {
+ id = id.substring(1);
+ }
+
+ while (startNode != null) {
+ if (startNode.getNodeType() == Node.ELEMENT_NODE) {
+ Element se = (Element) startNode;
+
+ NamedNodeMap attributes = se.getAttributes();
+ if (attributes != null) {
+ for (int i = 0; i < attributes.getLength(); i++) {
+ Attr attr = (Attr)attributes.item(i);
+ if (attr.isId() && id.equals(attr.getValue())) {
+ if (foundElement == null) {
+ // Continue searching to find duplicates
+ foundElement = attr.getOwnerElement();
+ } else {
+ //log.debug("Multiple elements with the same 'Id' attribute value!");
+ return false;
+ }
+ }
+ }
+ }
+ }
+
+ processedNode = startNode;
+ startNode = startNode.getFirstChild();
+
+ // no child, this node is done.
+ if (startNode == null) {
+ // close node processing, get sibling
+ startNode = processedNode.getNextSibling();
+ }
+
+ // no more siblings, get parent, all children
+ // of parent are processed.
+ while (startNode == null) {
+ processedNode = processedNode.getParentNode();
+ if (processedNode == startParent) {
+ return true;
+ }
+ // close parent node processing (processed node now)
+ startNode = processedNode.getNextSibling();
+ }
+ }
+ return true;
+ }
+
+ /**
+ * This method is a tree-search to help prevent against wrapping attacks. It checks that no other
+ * Element than the given "knownElement" argument has an ID attribute that matches the "value"
+ * argument, which is the ID value of "knownElement". If this is the case then "false" is returned.
+ */
+ public static boolean protectAgainstWrappingAttack(
+ Node startNode, Element knownElement, String value
+ ) {
+ Node startParent = startNode.getParentNode();
+ Node processedNode;
+
+ String id = value.trim();
+ if (id.charAt(0) == '#') {
+ id = id.substring(1);
+ }
+
+ while (startNode != null) {
+ if (startNode.getNodeType() == Node.ELEMENT_NODE) {
+ Element se = (Element) startNode;
+
+ NamedNodeMap attributes = se.getAttributes();
+ if (attributes != null) {
+ for (int i = 0; i < attributes.getLength(); i++) {
+ Attr attr = (Attr)attributes.item(i);
+ if (attr.isId() && id.equals(attr.getValue()) && se != knownElement) {
+ //log.debug("Multiple elements with the same 'Id' attribute value!");
+ return false;
+ }
+ }
+ }
+ }
+
+ processedNode = startNode;
+ startNode = startNode.getFirstChild();
+
+ // no child, this node is done.
+ if (startNode == null) {
+ // close node processing, get sibling
+ startNode = processedNode.getNextSibling();
+ }
+
+ // no more siblings, get parent, all children
+ // of parent are processed.
+ while (startNode == null) {
+ processedNode = processedNode.getParentNode();
+ if (processedNode == startParent) {
+ return true;
+ }
+ // close parent node processing (processed node now)
+ startNode = processedNode.getNextSibling();
+ }
+ }
+ return true;
+ }
+
+}
diff -pruN 1.8.4-1/ext/java/nokogiri/internals/ClosedStreamException.java 1.10.0+dfsg1-2/ext/java/nokogiri/internals/ClosedStreamException.java
--- 1.8.4-1/ext/java/nokogiri/internals/ClosedStreamException.java 1970-01-01 00:00:00.000000000 +0000
+++ 1.10.0+dfsg1-2/ext/java/nokogiri/internals/ClosedStreamException.java 2019-01-04 15:20:12.000000000 +0000
@@ -0,0 +1,10 @@
+package nokogiri.internals;
+
+@SuppressWarnings("serial")
+public class ClosedStreamException extends Exception {
+
+ public ClosedStreamException(String message) {
+ super(message);
+ }
+
+}
diff -pruN 1.8.4-1/ext/java/nokogiri/internals/dom2dtm/DOM2DTMdefaultNamespaceDeclarationNode.java 1.10.0+dfsg1-2/ext/java/nokogiri/internals/dom2dtm/DOM2DTMdefaultNamespaceDeclarationNode.java
--- 1.8.4-1/ext/java/nokogiri/internals/dom2dtm/DOM2DTMdefaultNamespaceDeclarationNode.java 1970-01-01 00:00:00.000000000 +0000
+++ 1.10.0+dfsg1-2/ext/java/nokogiri/internals/dom2dtm/DOM2DTMdefaultNamespaceDeclarationNode.java 2019-01-04 15:20:12.000000000 +0000
@@ -0,0 +1,685 @@
+/*
+ * reserved comment block
+ * DO NOT REMOVE OR ALTER!
+ */
+/*
+ * Copyright 1999-2004 The Apache Software Foundation.
+ *
+ * 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.
+ */
+/*
+ * $Id: DOM2DTMdefaultNamespaceDeclarationNode.java,v 1.2.4.1 2005/09/15 08:15:11 suresh_emailid Exp $
+ */
+
+// This is copied directly out of the original
+// com.sun.org.apache.xml.internal.dtm.ref.dom2dtm path to allow modifying
+// DOM2DTM and working around package private constructors. Other than the
+// package declaration, this class is unmodified
+
+package nokogiri.internals.dom2dtm;
+
+import org.apache.xml.dtm.DTMException;
+
+import org.w3c.dom.Attr;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.w3c.dom.TypeInfo;
+import org.w3c.dom.UserDataHandler;
+import org.w3c.dom.DOMException;
+
+/** This is a kluge to let us shove a declaration for xml: into the
+ * DOM2DTM model. Basically, it creates a proxy node in DOM space to
+ * carry the additional information. This is _NOT_ a full DOM
+ * implementation, and shouldn't be one since it sits alongside the
+ * DOM rather than becoming part of the DOM model.
+ *
+ * (This used to be an internal class within DOM2DTM. Moved out because
+ * I need to perform an instanceof operation on it to support a temporary
+ * workaround in DTMManagerDefault.)
+ *
+ * %REVIEW% What if the DOM2DTM was built around a DocumentFragment and
+ * there isn't a single root element? I think this fails that case...
+ *
+ * %REVIEW% An alternative solution would be to create the node _only_
+ * in DTM space, but given how DOM2DTM is currently written I think
+ * this is simplest.
+ * */
+public class DOM2DTMdefaultNamespaceDeclarationNode implements Attr,TypeInfo
+{
+ final String NOT_SUPPORTED_ERR="Unsupported operation on pseudonode";
+
+ Element pseudoparent;
+ String prefix,uri,nodename;
+ int handle;
+ DOM2DTMdefaultNamespaceDeclarationNode(Element pseudoparent,String prefix,String uri,int handle)
+ {
+ this.pseudoparent=pseudoparent;
+ this.prefix=prefix;
+ this.uri=uri;
+ this.handle=handle;
+ this.nodename="xmlns:"+prefix;
+ }
+ public String getNodeName() {return nodename;}
+ public String getName() {return nodename;}
+ public String getNamespaceURI() {return "http://www.w3.org/2000/xmlns/";}
+ public String getPrefix() {return prefix;}
+ public String getLocalName() {return prefix;}
+ public String getNodeValue() {return uri;}
+ public String getValue() {return uri;}
+ public Element getOwnerElement() {return pseudoparent;}
+
+ public boolean isSupported(String feature, String version) {return false;}
+ public boolean hasChildNodes() {return false;}
+ public boolean hasAttributes() {return false;}
+ public Node getParentNode() {return null;}
+ public Node getFirstChild() {return null;}
+ public Node getLastChild() {return null;}
+ public Node getPreviousSibling() {return null;}
+ public Node getNextSibling() {return null;}
+ public boolean getSpecified() {return false;}
+ public void normalize() {return;}
+ public NodeList getChildNodes() {return null;}
+ public NamedNodeMap getAttributes() {return null;}
+ public short getNodeType() {return Node.ATTRIBUTE_NODE;}
+ public void setNodeValue(String value) {throw new DTMException(NOT_SUPPORTED_ERR);}
+ public void setValue(String value) {throw new DTMException(NOT_SUPPORTED_ERR);}
+ public void setPrefix(String value) {throw new DTMException(NOT_SUPPORTED_ERR);}
+ public Node insertBefore(Node a, Node b) {throw new DTMException(NOT_SUPPORTED_ERR);}
+ public Node replaceChild(Node a, Node b) {throw new DTMException(NOT_SUPPORTED_ERR);}
+ public Node appendChild(Node a) {throw new DTMException(NOT_SUPPORTED_ERR);}
+ public Node removeChild(Node a) {throw new DTMException(NOT_SUPPORTED_ERR);}
+ public Document getOwnerDocument() {return pseudoparent.getOwnerDocument();}
+ public Node cloneNode(boolean deep) {throw new DTMException(NOT_SUPPORTED_ERR);}
+
+ /** Non-DOM method, part of the temporary kluge
+ * %REVIEW% This would be a pruning problem, but since it will always be
+ * added to the root element and we prune on elements, we shouldn't have
+ * to worry.
+ */
+ public int getHandleOfNode()
+ {
+ return handle;
+ }
+
+ //RAMESH: PENDING=> Add proper implementation for the below DOM L3 additions
+
+ /**
+ * @see org.w3c.dom.TypeInfo#getTypeName()
+ */
+ public String getTypeName() {return null; }
+
+ /**
+ * @see org.w3c.dom.TypeInfo#getTypeNamespace()
+ */
+ public String getTypeNamespace() { return null;}
+
+ /**
+ * @see or.gw3c.dom.TypeInfo#isDerivedFrom(String,String,int)
+ */
+ public boolean isDerivedFrom( String ns, String localName, int derivationMethod ) {
+ return false;
+ }
+
+ public TypeInfo getSchemaTypeInfo() { return this; }
+
+ public boolean isId( ) { return false; }
+
+ /**
+ * Associate an object to a key on this node. The object can later be
+ * retrieved from this node by calling getUserData with the
+ * same key.
+ * @param key The key to associate the object to.
+ * @param data The object to associate to the given key, or
+ * null to remove any existing association to that key.
+ * @param handler The handler to associate to that key, or
+ * null.
+ * @return Returns the DOMObject previously associated to
+ * the given key on this node, or null if there was none.
+ * @since DOM Level 3
+ */
+ public Object setUserData(String key,
+ Object data,
+ UserDataHandler handler) {
+ return getOwnerDocument().setUserData( key, data, handler);
+ }
+
+ /**
+ * Retrieves the object associated to a key on a this node. The object
+ * must first have been set to this node by calling
+ * setUserData with the same key.
+ * @param key The key the object is associated to.
+ * @return Returns the DOMObject associated to the given key
+ * on this node, or null if there was none.
+ * @since DOM Level 3
+ */
+ public Object getUserData(String key) {
+ return getOwnerDocument().getUserData( key);
+ }
+
+ /**
+ * This method returns a specialized object which implements the
+ * specialized APIs of the specified feature and version. The
+ * specialized object may also be obtained by using binding-specific
+ * casting methods but is not necessarily expected to, as discussed in Mixed DOM implementations.
+ * @param feature The name of the feature requested (case-insensitive).
+ * @param version This is the version number of the feature to test. If
+ * the version is null or the empty string, supporting
+ * any version of the feature will cause the method to return an
+ * object that supports at least one version of the feature.
+ * @return Returns an object which implements the specialized APIs of
+ * the specified feature and version, if any, or null if
+ * there is no object which implements interfaces associated with that
+ * feature. If the DOMObject returned by this method
+ * implements the Node interface, it must delegate to the
+ * primary core Node and not return results inconsistent
+ * with the primary core Node such as attributes,
+ * childNodes, etc.
+ * @since DOM Level 3
+ */
+ public Object getFeature(String feature, String version) {
+ // we don't have any alternate node, either this node does the job
+ // or we don't have anything that does
+ return isSupported(feature, version) ? this : null;
+ }
+
+ /**
+ * Tests whether two nodes are equal.
+ *
This method tests for equality of nodes, not sameness (i.e.,
+ * whether the two nodes are references to the same object) which can be
+ * tested with Node.isSameNode. All nodes that are the same
+ * will also be equal, though the reverse may not be true.
+ *
Two nodes are equal if and only if the following conditions are
+ * satisfied: The two nodes are of the same type.The following string
+ * attributes are equal: nodeName, localName,
+ * namespaceURI, prefix, nodeValue
+ * , baseURI. This is: they are both null, or
+ * they have the same length and are character for character identical.
+ * The attributes NamedNodeMaps are equal.
+ * This is: they are both null, or they have the same
+ * length and for each node that exists in one map there is a node that
+ * exists in the other map and is equal, although not necessarily at the
+ * same index.The childNodes NodeLists are
+ * equal. This is: they are both null, or they have the
+ * same length and contain equal nodes at the same index. This is true
+ * for Attr nodes as for any other type of node. Note that
+ * normalization can affect equality; to avoid this, nodes should be
+ * normalized before being compared.
+ *
For two DocumentType nodes to be equal, the following
+ * conditions must also be satisfied: The following string attributes
+ * are equal: publicId, systemId,
+ * internalSubset.The entities
+ * NamedNodeMaps are equal.The notations
+ * NamedNodeMaps are equal.
+ *
On the other hand, the following do not affect equality: the
+ * ownerDocument attribute, the specified
+ * attribute for Attr nodes, the
+ * isWhitespaceInElementContent attribute for
+ * Text nodes, as well as any user data or event listeners
+ * registered on the nodes.
+ * @param arg The node to compare equality with.
+ * @param deep If true, recursively compare the subtrees; if
+ * false, compare only the nodes themselves (and its
+ * attributes, if it is an Element).
+ * @return If the nodes, and possibly subtrees are equal,
+ * true otherwise false.
+ * @since DOM Level 3
+ */
+ public boolean isEqualNode(Node arg) {
+ if (arg == this) {
+ return true;
+ }
+ if (arg.getNodeType() != getNodeType()) {
+ return false;
+ }
+ // in theory nodeName can't be null but better be careful
+ // who knows what other implementations may be doing?...
+ if (getNodeName() == null) {
+ if (arg.getNodeName() != null) {
+ return false;
+ }
+ }
+ else if (!getNodeName().equals(arg.getNodeName())) {
+ return false;
+ }
+
+ if (getLocalName() == null) {
+ if (arg.getLocalName() != null) {
+ return false;
+ }
+ }
+ else if (!getLocalName().equals(arg.getLocalName())) {
+ return false;
+ }
+
+ if (getNamespaceURI() == null) {
+ if (arg.getNamespaceURI() != null) {
+ return false;
+ }
+ }
+ else if (!getNamespaceURI().equals(arg.getNamespaceURI())) {
+ return false;
+ }
+
+ if (getPrefix() == null) {
+ if (arg.getPrefix() != null) {
+ return false;
+ }
+ }
+ else if (!getPrefix().equals(arg.getPrefix())) {
+ return false;
+ }
+
+ if (getNodeValue() == null) {
+ if (arg.getNodeValue() != null) {
+ return false;
+ }
+ }
+ else if (!getNodeValue().equals(arg.getNodeValue())) {
+ return false;
+ }
+ /*
+ if (getBaseURI() == null) {
+ if (((NodeImpl) arg).getBaseURI() != null) {
+ return false;
+ }
+ }
+ else if (!getBaseURI().equals(((NodeImpl) arg).getBaseURI())) {
+ return false;
+ }
+*/
+
+ return true;
+ }
+
+ /**
+ * DOM Level 3 - Experimental:
+ * Look up the namespace URI associated to the given prefix, starting from this node.
+ * Use lookupNamespaceURI(null) to lookup the default namespace
+ *
+ * @param namespaceURI
+ * @return th URI for the namespace
+ * @since DOM Level 3
+ */
+ public String lookupNamespaceURI(String specifiedPrefix) {
+ short type = this.getNodeType();
+ switch (type) {
+ case Node.ELEMENT_NODE : {
+
+ String namespace = this.getNamespaceURI();
+ String prefix = this.getPrefix();
+ if (namespace !=null) {
+ // REVISIT: is it possible that prefix is empty string?
+ if (specifiedPrefix== null && prefix==specifiedPrefix) {
+ // looking for default namespace
+ return namespace;
+ } else if (prefix != null && prefix.equals(specifiedPrefix)) {
+ // non default namespace
+ return namespace;
+ }
+ }
+ if (this.hasAttributes()) {
+ NamedNodeMap map = this.getAttributes();
+ int length = map.getLength();
+ for (int i=0;inamespaceURI is the
+ * default namespace or not.
+ * @param namespaceURI The namespace URI to look for.
+ * @return true if the specified namespaceURI
+ * is the default namespace, false otherwise.
+ * @since DOM Level 3
+ */
+ public boolean isDefaultNamespace(String namespaceURI){
+ /*
+ // REVISIT: remove casts when DOM L3 becomes REC.
+ short type = this.getNodeType();
+ switch (type) {
+ case Node.ELEMENT_NODE: {
+ String namespace = this.getNamespaceURI();
+ String prefix = this.getPrefix();
+
+ // REVISIT: is it possible that prefix is empty string?
+ if (prefix == null || prefix.length() == 0) {
+ if (namespaceURI == null) {
+ return (namespace == namespaceURI);
+ }
+ return namespaceURI.equals(namespace);
+ }
+ if (this.hasAttributes()) {
+ ElementImpl elem = (ElementImpl)this;
+ NodeImpl attr = (NodeImpl)elem.getAttributeNodeNS("http://www.w3.org/2000/xmlns/", "xmlns");
+ if (attr != null) {
+ String value = attr.getNodeValue();
+ if (namespaceURI == null) {
+ return (namespace == value);
+ }
+ return namespaceURI.equals(value);
+ }
+ }
+
+ NodeImpl ancestor = (NodeImpl)getElementAncestor(this);
+ if (ancestor != null) {
+ return ancestor.isDefaultNamespace(namespaceURI);
+ }
+ return false;
+ }
+ case Node.DOCUMENT_NODE:{
+ return((NodeImpl)((Document)this).getDocumentElement()).isDefaultNamespace(namespaceURI);
+ }
+
+ case Node.ENTITY_NODE :
+ case Node.NOTATION_NODE:
+ case Node.DOCUMENT_FRAGMENT_NODE:
+ case Node.DOCUMENT_TYPE_NODE:
+ // type is unknown
+ return false;
+ case Node.ATTRIBUTE_NODE:{
+ if (this.ownerNode.getNodeType() == Node.ELEMENT_NODE) {
+ return ownerNode.isDefaultNamespace(namespaceURI);
+
+ }
+ return false;
+ }
+ default:{
+ NodeImpl ancestor = (NodeImpl)getElementAncestor(this);
+ if (ancestor != null) {
+ return ancestor.isDefaultNamespace(namespaceURI);
+ }
+ return false;
+ }
+
+ }
+*/
+ return false;
+
+
+ }
+
+ /**
+ *
+ * DOM Level 3 - Experimental:
+ * Look up the prefix associated to the given namespace URI, starting from this node.
+ *
+ * @param namespaceURI
+ * @return the prefix for the namespace
+ */
+ public String lookupPrefix(String namespaceURI){
+
+ // REVISIT: When Namespaces 1.1 comes out this may not be true
+ // Prefix can't be bound to null namespace
+ if (namespaceURI == null) {
+ return null;
+ }
+
+ short type = this.getNodeType();
+
+ switch (type) {
+/*
+ case Node.ELEMENT_NODE: {
+
+ String namespace = this.getNamespaceURI(); // to flip out children
+ return lookupNamespacePrefix(namespaceURI, (ElementImpl)this);
+ }
+
+ case Node.DOCUMENT_NODE:{
+ return((NodeImpl)((Document)this).getDocumentElement()).lookupPrefix(namespaceURI);
+ }
+*/
+ case Node.ENTITY_NODE :
+ case Node.NOTATION_NODE:
+ case Node.DOCUMENT_FRAGMENT_NODE:
+ case Node.DOCUMENT_TYPE_NODE:
+ // type is unknown
+ return null;
+ case Node.ATTRIBUTE_NODE:{
+ if (this.getOwnerElement().getNodeType() == Node.ELEMENT_NODE) {
+ return getOwnerElement().lookupPrefix(namespaceURI);
+
+ }
+ return null;
+ }
+ default:{
+/*
+ NodeImpl ancestor = (NodeImpl)getElementAncestor(this);
+ if (ancestor != null) {
+ return ancestor.lookupPrefix(namespaceURI);
+ }
+*/
+ return null;
+ }
+ }
+ }
+
+ /**
+ * Returns whether this node is the same node as the given one.
+ *
This method provides a way to determine whether two
+ * Node references returned by the implementation reference
+ * the same object. When two Node references are references
+ * to the same object, even if through a proxy, the references may be
+ * used completely interchangably, such that all attributes have the
+ * same values and calling the same DOM method on either reference
+ * always has exactly the same effect.
+ * @param other The node to test against.
+ * @return Returns true if the nodes are the same,
+ * false otherwise.
+ * @since DOM Level 3
+ */
+ public boolean isSameNode(Node other) {
+ // we do not use any wrapper so the answer is obvious
+ return this == other;
+ }
+
+ /**
+ * This attribute returns the text content of this node and its
+ * descendants. When it is defined to be null, setting it has no effect.
+ * When set, any possible children this node may have are removed and
+ * replaced by a single Text node containing the string
+ * this attribute is set to. On getting, no serialization is performed,
+ * the returned string does not contain any markup. No whitespace
+ * normalization is performed, the returned string does not contain the
+ * element content whitespaces . Similarly, on setting, no parsing is
+ * performed either, the input string is taken as pure textual content.
+ *
The string returned is made of the text content of this node
+ * depending on its type, as defined below:
+ *
+ *
+ * | Node type |
+ * Content |
+ *
+ *
+ * |
+ * ELEMENT_NODE, ENTITY_NODE, ENTITY_REFERENCE_NODE,
+ * DOCUMENT_FRAGMENT_NODE |
+ * concatenation of the textContent
+ * attribute value of every child node, excluding COMMENT_NODE and
+ * PROCESSING_INSTRUCTION_NODE nodes |
+ *
+ *
+ * | ATTRIBUTE_NODE, TEXT_NODE,
+ * CDATA_SECTION_NODE, COMMENT_NODE, PROCESSING_INSTRUCTION_NODE |
+ *
+ * nodeValue |
+ *
+ *
+ * | DOCUMENT_NODE, DOCUMENT_TYPE_NODE, NOTATION_NODE |
+ *
+ * null |
+ *
+ *
+ * @exception DOMException
+ * NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.
+ * @exception DOMException
+ * DOMSTRING_SIZE_ERR: Raised when it would return more characters than
+ * fit in a DOMString variable on the implementation
+ * platform.
+ * @since DOM Level 3
+ */
+ public void setTextContent(String textContent)
+ throws DOMException {
+ setNodeValue(textContent);
+ }
+
+ /**
+ * This attribute returns the text content of this node and its
+ * descendants. When it is defined to be null, setting it has no effect.
+ * When set, any possible children this node may have are removed and
+ * replaced by a single Text node containing the string
+ * this attribute is set to. On getting, no serialization is performed,
+ * the returned string does not contain any markup. No whitespace
+ * normalization is performed, the returned string does not contain the
+ * element content whitespaces . Similarly, on setting, no parsing is
+ * performed either, the input string is taken as pure textual content.
+ *
The string returned is made of the text content of this node
+ * depending on its type, as defined below:
+ *
+ *
+ * | Node type |
+ * Content |
+ *
+ *
+ * |
+ * ELEMENT_NODE, ENTITY_NODE, ENTITY_REFERENCE_NODE,
+ * DOCUMENT_FRAGMENT_NODE |
+ * concatenation of the textContent
+ * attribute value of every child node, excluding COMMENT_NODE and
+ * PROCESSING_INSTRUCTION_NODE nodes |
+ *
+ *
+ * | ATTRIBUTE_NODE, TEXT_NODE,
+ * CDATA_SECTION_NODE, COMMENT_NODE, PROCESSING_INSTRUCTION_NODE |
+ *
+ * nodeValue |
+ *
+ *
+ * | DOCUMENT_NODE, DOCUMENT_TYPE_NODE, NOTATION_NODE |
+ *
+ * null |
+ *
+ *
+ * @exception DOMException
+ * NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.
+ * @exception DOMException
+ * DOMSTRING_SIZE_ERR: Raised when it would return more characters than
+ * fit in a DOMString variable on the implementation
+ * platform.
+ * @since DOM Level 3
+ */
+ public String getTextContent() throws DOMException {
+ return getNodeValue(); // overriden in some subclasses
+ }
+
+ /**
+ * Compares a node with this node with regard to their position in the
+ * document.
+ * @param other The node to compare against this node.
+ * @return Returns how the given node is positioned relatively to this
+ * node.
+ * @since DOM Level 3
+ */
+ public short compareDocumentPosition(Node other) throws DOMException {
+ return 0;
+ }
+
+ /**
+ * The absolute base URI of this node or null if undefined.
+ * This value is computed according to . However, when the
+ * Document supports the feature "HTML" , the base URI is
+ * computed using first the value of the href attribute of the HTML BASE
+ * element if any, and the value of the documentURI
+ * attribute from the Document interface otherwise.
+ *
When the node is an Element, a Document
+ * or a a ProcessingInstruction, this attribute represents
+ * the properties [base URI] defined in . When the node is a
+ * Notation, an Entity, or an
+ * EntityReference, this attribute represents the
+ * properties [declaration base URI] in the . How will this be affected
+ * by resolution of relative namespace URIs issue?It's not.Should this
+ * only be on Document, Element, ProcessingInstruction, Entity, and
+ * Notation nodes, according to the infoset? If not, what is it equal to
+ * on other nodes? Null? An empty string? I think it should be the
+ * parent's.No.Should this be read-only and computed or and actual
+ * read-write attribute?Read-only and computed (F2F 19 Jun 2000 and
+ * teleconference 30 May 2001).If the base HTML element is not yet
+ * attached to a document, does the insert change the Document.baseURI?
+ * Yes. (F2F 26 Sep 2001)
+ * @since DOM Level 3
+ */
+ public String getBaseURI() {
+ return null;
+ }
+}
diff -pruN 1.8.4-1/ext/java/nokogiri/internals/dom2dtm/DOM2DTM.java 1.10.0+dfsg1-2/ext/java/nokogiri/internals/dom2dtm/DOM2DTM.java
--- 1.8.4-1/ext/java/nokogiri/internals/dom2dtm/DOM2DTM.java 1970-01-01 00:00:00.000000000 +0000
+++ 1.10.0+dfsg1-2/ext/java/nokogiri/internals/dom2dtm/DOM2DTM.java 2019-01-04 15:20:12.000000000 +0000
@@ -0,0 +1,1745 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 nokogiri.internals.dom2dtm;
+
+import javax.xml.transform.SourceLocator;
+import javax.xml.transform.dom.DOMSource;
+
+import org.apache.xml.dtm.DTM;
+import org.apache.xml.dtm.DTMManager;
+import org.apache.xml.dtm.DTMWSFilter;
+import org.apache.xml.dtm.ref.DTMDefaultBaseIterators;
+import org.apache.xml.dtm.ref.DTMManagerDefault;
+import org.apache.xml.dtm.ref.ExpandedNameTable;
+import org.apache.xml.dtm.ref.IncrementalSAXSource;
+import org.apache.xml.res.XMLErrorResources;
+import org.apache.xml.res.XMLMessages;
+import org.apache.xml.utils.FastStringBuffer;
+import org.apache.xml.utils.QName;
+import org.apache.xml.utils.StringBufferPool;
+import org.apache.xml.utils.TreeWalker;
+import org.apache.xml.utils.XMLCharacterRecognizer;
+import org.apache.xml.utils.XMLString;
+import org.apache.xml.utils.XMLStringFactory;
+import org.w3c.dom.Attr;
+import org.w3c.dom.Document;
+import org.w3c.dom.DocumentType;
+import org.w3c.dom.Element;
+import org.w3c.dom.Entity;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+import org.xml.sax.ContentHandler;
+
+/** The DOM2DTM class serves up a DOM's contents via the
+ * DTM API.
+ *
+ * Note that it doesn't necessarily represent a full Document
+ * tree. You can wrap a DOM2DTM around a specific node and its subtree
+ * and the right things should happen. (I don't _think_ we currently
+ * support DocumentFrgment nodes as roots, though that might be worth
+ * considering.)
+ *
+ * Note too that we do not currently attempt to track document
+ * mutation. If you alter the DOM after wrapping DOM2DTM around it,
+ * all bets are off.
+ * */
+public class DOM2DTM extends DTMDefaultBaseIterators
+{
+// static final boolean JJK_DEBUG=false;
+// static final boolean JJK_NEWCODE=true;
+
+ /** Manefest constant
+ */
+ static final String NAMESPACE_DECL_NS="http://www.w3.org/XML/1998/namespace";
+
+ /** The current position in the DOM tree. Last node examined for
+ * possible copying to DTM. */
+ transient private Node m_pos;
+ /** The current position in the DTM tree. Who children get appended to. */
+ private int m_last_parent=0;
+ /** The current position in the DTM tree. Who children reference as their
+ * previous sib. */
+ private int m_last_kid=NULL;
+
+ /** The top of the subtree.
+ * %REVIEW%: 'may not be the same as m_context if "//foo" pattern.'
+ * */
+ transient private Node m_root;
+
+ /** True iff the first element has been processed. This is used to control
+ synthesis of the implied xml: namespace declaration node. */
+ boolean m_processedFirstElement=false;
+
+ /** true if ALL the nodes in the m_root subtree have been processed;
+ * false if our incremental build has not yet finished scanning the
+ * DOM tree. */
+ transient private boolean m_nodesAreProcessed;
+
+ /** The node objects. The instance part of the handle indexes
+ * directly into this vector. Each DTM node may actually be
+ * composed of several DOM nodes (for example, if logically-adjacent
+ * Text/CDATASection nodes in the DOM have been coalesced into a
+ * single DTM Text node); this table points only to the first in
+ * that sequence. */
+ protected final java.util.List m_nodes = new java.util.ArrayList(12);
+
+ /**
+ * Construct a DOM2DTM object from a DOM node.
+ *
+ * @param mgr The DTMManager who owns this DTM.
+ * @param domSource the DOM source that this DTM will wrap.
+ * @param dtmIdentity The DTM identity ID for this DTM.
+ * @param whiteSpaceFilter The white space filter for this DTM, which may
+ * be null.
+ * @param xstringfactory XMLString factory for creating character content.
+ * @param doIndexing true if the caller considers it worth it to use
+ * indexing schemes.
+ */
+ public DOM2DTM(DTMManager mgr, DOMSource domSource,
+ int dtmIdentity, DTMWSFilter whiteSpaceFilter,
+ XMLStringFactory xstringfactory,
+ boolean doIndexing)
+ {
+ super(mgr, domSource, dtmIdentity, whiteSpaceFilter,
+ xstringfactory, doIndexing);
+
+ // Initialize DOM navigation
+ m_pos=m_root = domSource.getNode();
+ // Initialize DTM navigation
+ m_last_parent=m_last_kid=NULL;
+ m_last_kid=addNode(m_root, m_last_parent,m_last_kid, NULL);
+
+ // Apparently the domSource root may not actually be the
+ // Document node. If it's an Element node, we need to immediately
+ // add its attributes. Adapted from nextNode().
+ // %REVIEW% Move this logic into addNode and recurse? Cleaner!
+ //
+ // (If it's an EntityReference node, we're probably in
+ // seriously bad trouble. For now
+ // I'm just hoping nobody is ever quite that foolish... %REVIEW%)
+ //
+ // %ISSUE% What about inherited namespaces in this case?
+ // Do we need to special-case initialize them into the DTM model?
+ if(ELEMENT_NODE == m_root.getNodeType())
+ {
+ NamedNodeMap attrs=m_root.getAttributes();
+ int attrsize=(attrs==null) ? 0 : attrs.getLength();
+ if(attrsize>0)
+ {
+ int attrIndex=NULL; // start with no previous sib
+ for(int i=0;i>>DTMManager.IDENT_DTM_NODE_BITS))
+ {
+ try
+ {
+ if(m_mgr==null)
+ throw new ClassCastException();
+
+ // Handle as Extended Addressing
+ DTMManagerDefault mgrD=(DTMManagerDefault)m_mgr;
+ int id=mgrD.getFirstFreeDTMID();
+ mgrD.addDTM(this,id,nodeIndex);
+ m_dtmIdent.addElement(id<0)
+ {
+ for(int i=0;i= m_nodes.size())
+ {
+ if (!nextNode())
+ identity = DTM.NULL;
+ }
+
+ return identity;
+ }
+
+ /**
+ * Get the handle from a Node.
+ * %OPT% This will be pretty slow.
+ *
+ * %OPT% An XPath-like search (walk up DOM to root, tracking path;
+ * walk down DTM reconstructing path) might be considerably faster
+ * on later nodes in large documents. That might also imply improving
+ * this call to handle nodes which would be in this DTM but
+ * have not yet been built, which might or might not be a Good Thing.
+ *
+ * %REVIEW% This relies on being able to test node-identity via
+ * object-identity. DTM2DOM proxying is a great example of a case where
+ * that doesn't work. DOM Level 3 will provide the isSameNode() method
+ * to fix that, but until then this is going to be flaky.
+ *
+ * @param node A node, which may be null.
+ *
+ * @return The node handle or DTM.NULL.
+ */
+ public int getHandleFromNode(Node node)
+ {
+ if (null != node)
+ {
+ int len = m_nodes.size();
+ boolean isMore;
+ int i = 0;
+ do
+ {
+ for (; i < len; i++)
+ {
+ if (m_nodes.get(i) == node)
+ return makeNodeHandle(i);
+ }
+
+ isMore = nextNode();
+
+ len = m_nodes.size();
+
+ }
+ while(isMore || i < len);
+ }
+
+ return DTM.NULL;
+ }
+
+ /** Get the handle from a Node. This is a more robust version of
+ * getHandleFromNode, intended to be usable by the public.
+ *
+ * %OPT% This will be pretty slow.
+ *
+ * %REVIEW% This relies on being able to test node-identity via
+ * object-identity. DTM2DOM proxying is a great example of a case where
+ * that doesn't work. DOM Level 3 will provide the isSameNode() method
+ * to fix that, but until then this is going to be flaky.
+ *
+ * @param node A node, which may be null.
+ *
+ * @return The node handle or DTM.NULL. */
+ public int getHandleOfNode(Node node)
+ {
+ if (null != node)
+ {
+ // Is Node actually within the same document? If not, don't search!
+ // This would be easier if m_root was always the Document node, but
+ // we decided to allow wrapping a DTM around a subtree.
+ if((m_root==node) ||
+ (m_root.getNodeType()==DOCUMENT_NODE &&
+ m_root==node.getOwnerDocument()) ||
+ (m_root.getNodeType()!=DOCUMENT_NODE &&
+ m_root.getOwnerDocument()==node.getOwnerDocument())
+ )
+ {
+ // If node _is_ in m_root's tree, find its handle
+ //
+ // %OPT% This check may be improved significantly when DOM
+ // Level 3 nodeKey and relative-order tests become
+ // available!
+ for(Node cursor=node;
+ cursor!=null;
+ cursor=
+ (cursor.getNodeType()!=ATTRIBUTE_NODE)
+ ? cursor.getParentNode()
+ : ((org.w3c.dom.Attr)cursor).getOwnerElement())
+ {
+ if(cursor==m_root)
+ // We know this node; find its handle.
+ return getHandleFromNode(node);
+ } // for ancestors of node
+ } // if node and m_root in same Document
+ } // if node!=null
+
+ return DTM.NULL;
+ }
+
+ /**
+ * Retrieves an attribute node by by qualified name and namespace URI.
+ *
+ * @param nodeHandle int Handle of the node upon which to look up this attribute..
+ * @param namespaceURI The namespace URI of the attribute to
+ * retrieve, or null.
+ * @param name The local name of the attribute to
+ * retrieve.
+ * @return The attribute node handle with the specified name (
+ * nodeName) or DTM.NULL if there is no such
+ * attribute.
+ */
+ public int getAttributeNode(int nodeHandle, String namespaceURI,
+ String name)
+ {
+
+ // %OPT% This is probably slower than it needs to be.
+ if (null == namespaceURI)
+ namespaceURI = "";
+
+ int type = getNodeType(nodeHandle);
+
+ if (DTM.ELEMENT_NODE == type)
+ {
+
+ // Assume that attributes immediately follow the element.
+ int identity = makeNodeIdentity(nodeHandle);
+
+ while (DTM.NULL != (identity = getNextNodeIdentity(identity)))
+ {
+ // Assume this can not be null.
+ type = _type(identity);
+
+ // %REVIEW%
+ // Should namespace nodes be retrievable DOM-style as attrs?
+ // If not we need a separate function... which may be desirable
+ // architecturally, but which is ugly from a code point of view.
+ // (If we REALLY insist on it, this code should become a subroutine
+ // of both -- retrieve the node, then test if the type matches
+ // what you're looking for.)
+ if (type == DTM.ATTRIBUTE_NODE || type==DTM.NAMESPACE_NODE)
+ {
+ Node node = lookupNode(identity);
+ String nodeuri = node.getNamespaceURI();
+
+ if (null == nodeuri)
+ nodeuri = "";
+
+ String nodelocalname = node.getLocalName();
+
+ if (nodeuri.equals(namespaceURI) && name.equals(nodelocalname))
+ return makeNodeHandle(identity);
+ }
+
+ else // if (DTM.NAMESPACE_NODE != type)
+ {
+ break;
+ }
+ }
+ }
+
+ return DTM.NULL;
+ }
+
+ /**
+ * Get the string-value of a node as a String object
+ * (see http://www.w3.org/TR/xpath#data-model
+ * for the definition of a node's string-value).
+ *
+ * @param nodeHandle The node ID.
+ *
+ * @return A string object that represents the string-value of the given node.
+ */
+ public XMLString getStringValue(int nodeHandle)
+ {
+
+ int type = getNodeType(nodeHandle);
+ Node node = getNode(nodeHandle);
+ // %TBD% If an element only has one text node, we should just use it
+ // directly.
+ if(DTM.ELEMENT_NODE == type || DTM.DOCUMENT_NODE == type
+ || DTM.DOCUMENT_FRAGMENT_NODE == type)
+ {
+ FastStringBuffer buf = StringBufferPool.get();
+ String s;
+
+ try
+ {
+ getNodeData(node, buf);
+
+ s = (buf.length() > 0) ? buf.toString() : "";
+ }
+ finally
+ {
+ StringBufferPool.free(buf);
+ }
+
+ return m_xstrf.newstr( s );
+ }
+ else if(TEXT_NODE == type || CDATA_SECTION_NODE == type)
+ {
+ // If this is a DTM text node, it may be made of multiple DOM text
+ // nodes -- including navigating into Entity References. DOM2DTM
+ // records the first node in the sequence and requires that we
+ // pick up the others when we retrieve the DTM node's value.
+ //
+ // %REVIEW% DOM Level 3 is expected to add a "whole text"
+ // retrieval method which performs this function for us.
+ FastStringBuffer buf = StringBufferPool.get();
+ while(node!=null)
+ {
+ buf.append(node.getNodeValue());
+ node=logicalNextDOMTextNode(node);
+ }
+ String s=(buf.length() > 0) ? buf.toString() : "";
+ StringBufferPool.free(buf);
+ return m_xstrf.newstr( s );
+ }
+ else
+ return m_xstrf.newstr( node.getNodeValue() );
+ }
+
+ /**
+ * Determine if the string-value of a node is whitespace
+ *
+ * @param nodeHandle The node Handle.
+ *
+ * @return Return true if the given node is whitespace.
+ */
+ public boolean isWhitespace(int nodeHandle)
+ {
+ int type = getNodeType(nodeHandle);
+ Node node = getNode(nodeHandle);
+ if(TEXT_NODE == type || CDATA_SECTION_NODE == type)
+ {
+ // If this is a DTM text node, it may be made of multiple DOM text
+ // nodes -- including navigating into Entity References. DOM2DTM
+ // records the first node in the sequence and requires that we
+ // pick up the others when we retrieve the DTM node's value.
+ //
+ // %REVIEW% DOM Level 3 is expected to add a "whole text"
+ // retrieval method which performs this function for us.
+ FastStringBuffer buf = StringBufferPool.get();
+ while(node!=null)
+ {
+ buf.append(node.getNodeValue());
+ node=logicalNextDOMTextNode(node);
+ }
+ boolean b = buf.isWhitespace(0, buf.length());
+ StringBufferPool.free(buf);
+ return b;
+ }
+ return false;
+ }
+
+ /**
+ * Retrieve the text content of a DOM subtree, appending it into a
+ * user-supplied FastStringBuffer object. Note that attributes are
+ * not considered part of the content of an element.
+ *
+ * There are open questions regarding whitespace stripping.
+ * Currently we make no special effort in that regard, since the standard
+ * DOM doesn't yet provide DTD-based information to distinguish
+ * whitespace-in-element-context from genuine #PCDATA. Note that we
+ * should probably also consider xml:space if/when we address this.
+ * DOM Level 3 may solve the problem for us.
+ *
+ * %REVIEW% Actually, since this method operates on the DOM side of the
+ * fence rather than the DTM side, it SHOULDN'T do
+ * any special handling. The DOM does what the DOM does; if you want
+ * DTM-level abstractions, use DTM-level methods.
+ *
+ * @param node Node whose subtree is to be walked, gathering the
+ * contents of all Text or CDATASection nodes.
+ * @param buf FastStringBuffer into which the contents of the text
+ * nodes are to be concatenated.
+ */
+ protected static void getNodeData(Node node, FastStringBuffer buf)
+ {
+
+ switch (node.getNodeType())
+ {
+ case Node.DOCUMENT_FRAGMENT_NODE :
+ case Node.DOCUMENT_NODE :
+ case Node.ELEMENT_NODE :
+ {
+ for (Node child = node.getFirstChild(); null != child;
+ child = child.getNextSibling())
+ {
+ getNodeData(child, buf);
+ }
+ }
+ break;
+ case Node.TEXT_NODE :
+ case Node.CDATA_SECTION_NODE :
+ case Node.ATTRIBUTE_NODE : // Never a child but might be our starting node
+ buf.append(node.getNodeValue());
+ break;
+ case Node.PROCESSING_INSTRUCTION_NODE :
+ // warning(XPATHErrorResources.WG_PARSING_AND_PREPARING);
+ break;
+ default :
+ // ignore
+ break;
+ }
+ }
+
+ /**
+ * Given a node handle, return its DOM-style node name. This will
+ * include names such as #text or #document.
+ *
+ * @param nodeHandle the id of the node.
+ * @return String Name of this node, which may be an empty string.
+ * %REVIEW% Document when empty string is possible...
+ * %REVIEW-COMMENT% It should never be empty, should it?
+ */
+ public String getNodeName(int nodeHandle)
+ {
+
+ Node node = getNode(nodeHandle);
+
+ // Assume non-null.
+ return node.getNodeName();
+ }
+
+ /**
+ * Given a node handle, return the XPath node name. This should be
+ * the name as described by the XPath data model, NOT the DOM-style
+ * name.
+ *
+ * @param nodeHandle the id of the node.
+ * @return String Name of this node, which may be an empty string.
+ */
+ public String getNodeNameX(int nodeHandle)
+ {
+
+ String name;
+ short type = getNodeType(nodeHandle);
+
+ switch (type)
+ {
+ case DTM.NAMESPACE_NODE :
+ {
+ Node node = getNode(nodeHandle);
+
+ // assume not null.
+ name = node.getNodeName();
+ if(name.startsWith("xmlns:"))
+ {
+ name = QName.getLocalPart(name);
+ }
+ else if(name.equals("xmlns"))
+ {
+ name = "";
+ }
+ }
+ break;
+ case DTM.ATTRIBUTE_NODE :
+ case DTM.ELEMENT_NODE :
+ case DTM.ENTITY_REFERENCE_NODE :
+ case DTM.PROCESSING_INSTRUCTION_NODE :
+ {
+ Node node = getNode(nodeHandle);
+
+ // assume not null.
+ name = node.getNodeName();
+ }
+ break;
+ default :
+ name = "";
+ }
+
+ return name;
+ }
+
+ /**
+ * Given a node handle, return its XPath-style localname.
+ * (As defined in Namespaces, this is the portion of the name after any
+ * colon character).
+ *
+ * @param nodeHandle the id of the node.
+ * @return String Local name of this node.
+ */
+ public String getLocalName(int nodeHandle)
+ {
+// if(JJK_NEWCODE)
+// {
+ int id=makeNodeIdentity(nodeHandle);
+ if(NULL==id) return null;
+ Node newnode=(Node)m_nodes.get(id);
+ String newname=newnode.getLocalName();
+ if (null == newname)
+ {
+ // XSLT treats PIs, and possibly other things, as having QNames.
+ String qname = newnode.getNodeName();
+ if('#'==qname.charAt(0))
+ {
+ // Match old default for this function
+ // This conversion may or may not be necessary
+ newname="";
+ }
+ else
+ {
+ int index = qname.indexOf(':');
+ newname = (index < 0) ? qname : qname.substring(index + 1);
+ }
+ }
+ return newname;
+// }
+// else
+// {
+// String name;
+// short type = getNodeType(nodeHandle);
+// switch (type)
+// {
+// case DTM.ATTRIBUTE_NODE :
+// case DTM.ELEMENT_NODE :
+// case DTM.ENTITY_REFERENCE_NODE :
+// case DTM.NAMESPACE_NODE :
+// case DTM.PROCESSING_INSTRUCTION_NODE :
+// {
+// Node node = getNode(nodeHandle);
+//
+// // assume not null.
+// name = node.getLocalName();
+//
+// if (null == name)
+// {
+// String qname = node.getNodeName();
+// int index = qname.indexOf(':');
+//
+// name = (index < 0) ? qname : qname.substring(index + 1);
+// }
+// }
+// break;
+// default :
+// name = "";
+// }
+// return name;
+// }
+ }
+
+ /**
+ * Given a namespace handle, return the prefix that the namespace decl is
+ * mapping.
+ * Given a node handle, return the prefix used to map to the namespace.
+ *
+ *
%REVIEW% Are you sure you want "" for no prefix?
+ * %REVIEW-COMMENT% I think so... not totally sure. -sb
+ *
+ * @param nodeHandle the id of the node.
+ * @return String prefix of this node's name, or "" if no explicit
+ * namespace prefix was given.
+ */
+ public String getPrefix(int nodeHandle)
+ {
+
+ String prefix;
+ short type = getNodeType(nodeHandle);
+
+ switch (type)
+ {
+ case DTM.NAMESPACE_NODE :
+ {
+ Node node = getNode(nodeHandle);
+
+ // assume not null.
+ String qname = node.getNodeName();
+ int index = qname.indexOf(':');
+
+ prefix = (index < 0) ? "" : qname.substring(index + 1);
+ }
+ break;
+ case DTM.ATTRIBUTE_NODE :
+ case DTM.ELEMENT_NODE :
+ {
+ Node node = getNode(nodeHandle);
+
+ // assume not null.
+ String qname = node.getNodeName();
+ int index = qname.indexOf(':');
+
+ prefix = (index < 0) ? "" : qname.substring(0, index);
+ }
+ break;
+ default :
+ prefix = "";
+ }
+
+ return prefix;
+ }
+
+ /**
+ * Given a node handle, return its DOM-style namespace URI
+ * (As defined in Namespaces, this is the declared URI which this node's
+ * prefix -- or default in lieu thereof -- was mapped to.)
+ *
+ * %REVIEW% Null or ""? -sb
+ *
+ * @param nodeHandle the id of the node.
+ * @return String URI value of this node's namespace, or null if no
+ * namespace was resolved.
+ */
+ public String getNamespaceURI(int nodeHandle)
+ {
+// if(JJK_NEWCODE)
+// {
+ int id=makeNodeIdentity(nodeHandle);
+ if(id==NULL) return null;
+ Node node=(Node)m_nodes.get(id);
+ return node.getNamespaceURI();
+// }
+// else
+// {
+// String nsuri;
+// short type = getNodeType(nodeHandle);
+//
+// switch (type)
+// {
+// case DTM.ATTRIBUTE_NODE :
+// case DTM.ELEMENT_NODE :
+// case DTM.ENTITY_REFERENCE_NODE :
+// case DTM.NAMESPACE_NODE :
+// case DTM.PROCESSING_INSTRUCTION_NODE :
+// {
+// Node node = getNode(nodeHandle);
+//
+// // assume not null.
+// nsuri = node.getNamespaceURI();
+//
+// // %TBD% Handle DOM1?
+// }
+// break;
+// default :
+// nsuri = null;
+// }
+//
+// return nsuri;
+// }
+ }
+
+ /** Utility function: Given a DOM Text node, determine whether it is
+ * logically followed by another Text or CDATASection node. This may
+ * involve traversing into Entity References.
+ *
+ * %REVIEW% DOM Level 3 is expected to add functionality which may
+ * allow us to retire this.
+ */
+ private Node logicalNextDOMTextNode(Node n)
+ {
+ Node p=n.getNextSibling();
+ if(p==null)
+ {
+ // Walk out of any EntityReferenceNodes that ended with text
+ for(n=n.getParentNode();
+ n!=null && ENTITY_REFERENCE_NODE == n.getNodeType();
+ n=n.getParentNode())
+ {
+ p=n.getNextSibling();
+ if(p!=null)
+ break;
+ }
+ }
+ n=p;
+ while(n!=null && ENTITY_REFERENCE_NODE == n.getNodeType())
+ {
+ // Walk into any EntityReferenceNodes that start with text
+ if(n.hasChildNodes())
+ n=n.getFirstChild();
+ else
+ n=n.getNextSibling();
+ }
+ if(n!=null)
+ {
+ // Found a logical next sibling. Is it text?
+ int ntype=n.getNodeType();
+ if(TEXT_NODE != ntype && CDATA_SECTION_NODE != ntype)
+ n=null;
+ }
+ return n;
+ }
+
+ /**
+ * Given a node handle, return its node value. This is mostly
+ * as defined by the DOM, but may ignore some conveniences.
+ *
+ *
+ * @param nodeHandle The node id.
+ * @return String Value of this node, or null if not
+ * meaningful for this node type.
+ */
+ public String getNodeValue(int nodeHandle)
+ {
+ // The _type(nodeHandle) call was taking the lion's share of our
+ // time, and was wrong anyway since it wasn't coverting handle to
+ // identity. Inlined it.
+ int type = _exptype(makeNodeIdentity(nodeHandle));
+ type=(NULL != type) ? getNodeType(nodeHandle) : NULL;
+
+ if(TEXT_NODE!=type && CDATA_SECTION_NODE!=type)
+ return getNode(nodeHandle).getNodeValue();
+
+ // If this is a DTM text node, it may be made of multiple DOM text
+ // nodes -- including navigating into Entity References. DOM2DTM
+ // records the first node in the sequence and requires that we
+ // pick up the others when we retrieve the DTM node's value.
+ //
+ // %REVIEW% DOM Level 3 is expected to add a "whole text"
+ // retrieval method which performs this function for us.
+ Node node = getNode(nodeHandle);
+ Node n=logicalNextDOMTextNode(node);
+ if(n==null)
+ return node.getNodeValue();
+
+ FastStringBuffer buf = StringBufferPool.get();
+ buf.append(node.getNodeValue());
+ while(n!=null)
+ {
+ buf.append(n.getNodeValue());
+ n=logicalNextDOMTextNode(n);
+ }
+ String s = (buf.length() > 0) ? buf.toString() : "";
+ StringBufferPool.free(buf);
+ return s;
+ }
+
+ /**
+ * A document type declaration information item has the following properties:
+ *
+ * 1. [system identifier] The system identifier of the external subset, if
+ * it exists. Otherwise this property has no value.
+ *
+ * @return the system identifier String object, or null if there is none.
+ */
+ public String getDocumentTypeDeclarationSystemIdentifier()
+ {
+
+ Document doc;
+
+ if (m_root.getNodeType() == Node.DOCUMENT_NODE)
+ doc = (Document) m_root;
+ else
+ doc = m_root.getOwnerDocument();
+
+ if (null != doc)
+ {
+ DocumentType dtd = doc.getDoctype();
+
+ if (null != dtd)
+ {
+ return dtd.getSystemId();
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * Return the public identifier of the external subset,
+ * normalized as described in 4.2.2 External Entities [XML]. If there is
+ * no external subset or if it has no public identifier, this property
+ * has no value.
+ *
+ * @return the public identifier String object, or null if there is none.
+ */
+ public String getDocumentTypeDeclarationPublicIdentifier()
+ {
+
+ Document doc;
+
+ if (m_root.getNodeType() == Node.DOCUMENT_NODE)
+ doc = (Document) m_root;
+ else
+ doc = m_root.getOwnerDocument();
+
+ if (null != doc)
+ {
+ DocumentType dtd = doc.getDoctype();
+
+ if (null != dtd)
+ {
+ return dtd.getPublicId();
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * Returns the Element whose ID is given by
+ * elementId. If no such element exists, returns
+ * DTM.NULL. Behavior is not defined if more than one element
+ * has this ID. Attributes (including those
+ * with the name "ID") are not of type ID unless so defined by DTD/Schema
+ * information available to the DTM implementation.
+ * Implementations that do not know whether attributes are of type ID or
+ * not are expected to return DTM.NULL.
+ *
+ *
%REVIEW% Presumably IDs are still scoped to a single document,
+ * and this operation searches only within a single document, right?
+ * Wouldn't want collisions between DTMs in the same process.
+ *
+ * @param elementId The unique id value for an element.
+ * @return The handle of the matching element.
+ */
+ public int getElementById(String elementId)
+ {
+
+ Document doc = (m_root.getNodeType() == Node.DOCUMENT_NODE)
+ ? (Document) m_root : m_root.getOwnerDocument();
+
+ if(null != doc)
+ {
+ Node elem = doc.getElementById(elementId);
+ if(null != elem)
+ {
+ int elemHandle = getHandleFromNode(elem);
+
+ if(DTM.NULL == elemHandle)
+ {
+ int identity = m_nodes.size()-1;
+ while (DTM.NULL != (identity = getNextNodeIdentity(identity)))
+ {
+ Node node = getNode(identity);
+ if(node == elem)
+ {
+ elemHandle = getHandleFromNode(elem);
+ break;
+ }
+ }
+ }
+
+ return elemHandle;
+ }
+
+ }
+ return DTM.NULL;
+ }
+
+ /**
+ * The getUnparsedEntityURI function returns the URI of the unparsed
+ * entity with the specified name in the same document as the context
+ * node (see [3.3 Unparsed Entities]). It returns the empty string if
+ * there is no such entity.
+ *
+ * XML processors may choose to use the System Identifier (if one
+ * is provided) to resolve the entity, rather than the URI in the
+ * Public Identifier. The details are dependent on the processor, and
+ * we would have to support some form of plug-in resolver to handle
+ * this properly. Currently, we simply return the System Identifier if
+ * present, and hope that it a usable URI or that our caller can
+ * map it to one.
+ * TODO: Resolve Public Identifiers... or consider changing function name.
+ *
+ * If we find a relative URI
+ * reference, XML expects it to be resolved in terms of the base URI
+ * of the document. The DOM doesn't do that for us, and it isn't
+ * entirely clear whether that should be done here; currently that's
+ * pushed up to a higher level of our application. (Note that DOM Level
+ * 1 didn't store the document's base URI.)
+ * TODO: Consider resolving Relative URIs.
+ *
+ * (The DOM's statement that "An XML processor may choose to
+ * completely expand entities before the structure model is passed
+ * to the DOM" refers only to parsed entities, not unparsed, and hence
+ * doesn't affect this function.)
+ *
+ * @param name A string containing the Entity Name of the unparsed
+ * entity.
+ *
+ * @return String containing the URI of the Unparsed Entity, or an
+ * empty string if no such entity exists.
+ */
+ public String getUnparsedEntityURI(String name)
+ {
+
+ String url = "";
+ Document doc = (m_root.getNodeType() == Node.DOCUMENT_NODE)
+ ? (Document) m_root : m_root.getOwnerDocument();
+
+ if (null != doc)
+ {
+ DocumentType doctype = doc.getDoctype();
+
+ if (null != doctype)
+ {
+ NamedNodeMap entities = doctype.getEntities();
+ if(null == entities)
+ return url;
+ Entity entity = (Entity) entities.getNamedItem(name);
+ if(null == entity)
+ return url;
+
+ String notationName = entity.getNotationName();
+
+ if (null != notationName) // then it's unparsed
+ {
+ // The draft says: "The XSLT processor may use the public
+ // identifier to generate a URI for the entity instead of the URI
+ // specified in the system identifier. If the XSLT processor does
+ // not use the public identifier to generate the URI, it must use
+ // the system identifier; if the system identifier is a relative
+ // URI, it must be resolved into an absolute URI using the URI of
+ // the resource containing the entity declaration as the base
+ // URI [RFC2396]."
+ // So I'm falling a bit short here.
+ url = entity.getSystemId();
+
+ if (null == url)
+ {
+ url = entity.getPublicId();
+ }
+ else
+ {
+ // This should be resolved to an absolute URL, but that's hard
+ // to do from here.
+ }
+ }
+ }
+ }
+
+ return url;
+ }
+
+ /**
+ * 5. [specified] A flag indicating whether this attribute was actually
+ * specified in the start-tag of its element, or was defaulted from the
+ * DTD.
+ *
+ * @param attributeHandle the attribute handle
+ * @return true if the attribute was specified;
+ * false if it was defaulted.
+ */
+ public boolean isAttributeSpecified(int attributeHandle)
+ {
+ int type = getNodeType(attributeHandle);
+
+ if (DTM.ATTRIBUTE_NODE == type)
+ {
+ Attr attr = (Attr)getNode(attributeHandle);
+ return attr.getSpecified();
+ }
+ return false;
+ }
+
+ /** Bind an IncrementalSAXSource to this DTM. NOT RELEVANT for DOM2DTM, since
+ * we're wrapped around an existing DOM.
+ *
+ * @param source The IncrementalSAXSource that we want to recieve events from
+ * on demand.
+ */
+ public void setIncrementalSAXSource(IncrementalSAXSource source)
+ {
+ }
+
+ /** getContentHandler returns "our SAX builder" -- the thing that
+ * someone else should send SAX events to in order to extend this
+ * DTM model.
+ *
+ * @return null if this model doesn't respond to SAX events,
+ * "this" if the DTM object has a built-in SAX ContentHandler,
+ * the IncrmentalSAXSource if we're bound to one and should receive
+ * the SAX stream via it for incremental build purposes...
+ * */
+ public org.xml.sax.ContentHandler getContentHandler()
+ {
+ return null;
+ }
+
+ /**
+ * Return this DTM's lexical handler.
+ *
+ * %REVIEW% Should this return null if constrution already done/begun?
+ *
+ * @return null if this model doesn't respond to lexical SAX events,
+ * "this" if the DTM object has a built-in SAX ContentHandler,
+ * the IncrementalSAXSource if we're bound to one and should receive
+ * the SAX stream via it for incremental build purposes...
+ */
+ public org.xml.sax.ext.LexicalHandler getLexicalHandler()
+ {
+
+ return null;
+ }
+
+
+ /**
+ * Return this DTM's EntityResolver.
+ *
+ * @return null if this model doesn't respond to SAX entity ref events.
+ */
+ public org.xml.sax.EntityResolver getEntityResolver()
+ {
+
+ return null;
+ }
+
+ /**
+ * Return this DTM's DTDHandler.
+ *
+ * @return null if this model doesn't respond to SAX dtd events.
+ */
+ public org.xml.sax.DTDHandler getDTDHandler()
+ {
+
+ return null;
+ }
+
+ /**
+ * Return this DTM's ErrorHandler.
+ *
+ * @return null if this model doesn't respond to SAX error events.
+ */
+ public org.xml.sax.ErrorHandler getErrorHandler()
+ {
+
+ return null;
+ }
+
+ /**
+ * Return this DTM's DeclHandler.
+ *
+ * @return null if this model doesn't respond to SAX Decl events.
+ */
+ public org.xml.sax.ext.DeclHandler getDeclHandler()
+ {
+
+ return null;
+ }
+
+ /** @return true iff we're building this model incrementally (eg
+ * we're partnered with a IncrementalSAXSource) and thus require that the
+ * transformation and the parse run simultaneously. Guidance to the
+ * DTMManager.
+ * */
+ public boolean needsTwoThreads()
+ {
+ return false;
+ }
+
+ // ========== Direct SAX Dispatch, for optimization purposes ========
+
+ /**
+ * Returns whether the specified ch conforms to the XML 1.0 definition
+ * of whitespace. Refer to
+ * the definition of S for details.
+ * @param ch Character to check as XML whitespace.
+ * @return =true if ch is XML whitespace; otherwise =false.
+ */
+ private static boolean isSpace(char ch)
+ {
+ return XMLCharacterRecognizer.isWhiteSpace(ch); // Take the easy way out for now.
+ }
+
+ /**
+ * Directly call the
+ * characters method on the passed ContentHandler for the
+ * string-value of the given node (see http://www.w3.org/TR/xpath#data-model
+ * for the definition of a node's string-value). Multiple calls to the
+ * ContentHandler's characters methods may well occur for a single call to
+ * this method.
+ *
+ * @param nodeHandle The node ID.
+ * @param ch A non-null reference to a ContentHandler.
+ *
+ * @throws org.xml.sax.SAXException
+ */
+ public void dispatchCharactersEvents(
+ int nodeHandle, org.xml.sax.ContentHandler ch,
+ boolean normalize)
+ throws org.xml.sax.SAXException
+ {
+ if(normalize)
+ {
+ XMLString str = getStringValue(nodeHandle);
+ str = str.fixWhiteSpace(true, true, false);
+ str.dispatchCharactersEvents(ch);
+ }
+ else
+ {
+ int type = getNodeType(nodeHandle);
+ Node node = getNode(nodeHandle);
+ dispatchNodeData(node, ch, 0);
+ // Text coalition -- a DTM text node may represent multiple
+ // DOM nodes.
+ if(TEXT_NODE == type || CDATA_SECTION_NODE == type)
+ {
+ while( null != (node=logicalNextDOMTextNode(node)) )
+ {
+ dispatchNodeData(node, ch, 0);
+ }
+ }
+ }
+ }
+
+ /**
+ * Retrieve the text content of a DOM subtree, appending it into a
+ * user-supplied FastStringBuffer object. Note that attributes are
+ * not considered part of the content of an element.
+ *
+ * There are open questions regarding whitespace stripping.
+ * Currently we make no special effort in that regard, since the standard
+ * DOM doesn't yet provide DTD-based information to distinguish
+ * whitespace-in-element-context from genuine #PCDATA. Note that we
+ * should probably also consider xml:space if/when we address this.
+ * DOM Level 3 may solve the problem for us.
+ *
+ * %REVIEW% Note that as a DOM-level operation, it can be argued that this
+ * routine _shouldn't_ perform any processing beyond what the DOM already
+ * does, and that whitespace stripping and so on belong at the DTM level.
+ * If you want a stripped DOM view, wrap DTM2DOM around DOM2DTM.
+ *
+ * @param node Node whose subtree is to be walked, gathering the
+ * contents of all Text or CDATASection nodes.
+ */
+ protected static void dispatchNodeData(Node node,
+ org.xml.sax.ContentHandler ch,
+ int depth)
+ throws org.xml.sax.SAXException
+ {
+
+ switch (node.getNodeType())
+ {
+ case Node.DOCUMENT_FRAGMENT_NODE :
+ case Node.DOCUMENT_NODE :
+ case Node.ELEMENT_NODE :
+ {
+ for (Node child = node.getFirstChild(); null != child;
+ child = child.getNextSibling())
+ {
+ dispatchNodeData(child, ch, depth+1);
+ }
+ }
+ break;
+ case Node.PROCESSING_INSTRUCTION_NODE : // %REVIEW%
+ case Node.COMMENT_NODE :
+ if(0 != depth)
+ break;
+ // NOTE: Because this operation works in the DOM space, it does _not_ attempt
+ // to perform Text Coalition. That should only be done in DTM space.
+ case Node.TEXT_NODE :
+ case Node.CDATA_SECTION_NODE :
+ case Node.ATTRIBUTE_NODE :
+ String str = node.getNodeValue();
+ if(ch instanceof org.apache.xml.dtm.ref.dom2dtm.DOM2DTM.CharacterNodeHandler)
+ {
+ ((org.apache.xml.dtm.ref.dom2dtm.DOM2DTM.CharacterNodeHandler)ch).characters(node);
+ }
+ else
+ {
+ ch.characters(str.toCharArray(), 0, str.length());
+ }
+ break;
+// /* case Node.PROCESSING_INSTRUCTION_NODE :
+// // warning(XPATHErrorResources.WG_PARSING_AND_PREPARING);
+// break; */
+ default :
+ // ignore
+ break;
+ }
+ }
+
+ TreeWalker m_walker = new TreeWalker(null);
+
+ /**
+ * Directly create SAX parser events from a subtree.
+ *
+ * @param nodeHandle The node ID.
+ * @param ch A non-null reference to a ContentHandler.
+ *
+ * @throws org.xml.sax.SAXException
+ */
+ public void dispatchToEvents(int nodeHandle, org.xml.sax.ContentHandler ch)
+ throws org.xml.sax.SAXException
+ {
+ TreeWalker treeWalker = m_walker;
+ ContentHandler prevCH = treeWalker.getContentHandler();
+
+ if(null != prevCH)
+ {
+ treeWalker = new TreeWalker(null);
+ }
+ treeWalker.setContentHandler(ch);
+
+ try
+ {
+ Node node = getNode(nodeHandle);
+ treeWalker.traverseFragment(node);
+ }
+ finally
+ {
+ treeWalker.setContentHandler(null);
+ }
+ }
+
+ /**
+ * For the moment all the run time properties are ignored by this
+ * class.
+ *
+ * @param property a String value
+ * @param value an Object value
+ */
+ public void setProperty(String property, Object value)
+ {
+ }
+
+ /**
+ * No source information is available for DOM2DTM, so return
+ * null here.
+ *
+ * @param node an int value
+ * @return null
+ */
+ public SourceLocator getSourceLocatorFor(int node)
+ {
+ return null;
+ }
+
+}
+
+
diff -pruN 1.8.4-1/ext/java/nokogiri/internals/HtmlDomParserContext.java 1.10.0+dfsg1-2/ext/java/nokogiri/internals/HtmlDomParserContext.java
--- 1.8.4-1/ext/java/nokogiri/internals/HtmlDomParserContext.java 1970-01-01 00:00:00.000000000 +0000
+++ 1.10.0+dfsg1-2/ext/java/nokogiri/internals/HtmlDomParserContext.java 2019-01-04 15:20:12.000000000 +0000
@@ -0,0 +1,246 @@
+/**
+ * (The MIT License)
+ *
+ * Copyright (c) 2008 - 2012:
+ *
+ * * {Aaron Patterson}[http://tenderlovemaking.com]
+ * * {Mike Dalessio}[http://mike.daless.io]
+ * * {Charles Nutter}[http://blog.headius.com]
+ * * {Sergio Arbeo}[http://www.serabe.com]
+ * * {Patrick Mahoney}[http://polycrystal.org]
+ * * {Yoko Harada}[http://yokolet.blogspot.com]
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package nokogiri.internals;
+
+import static nokogiri.internals.NokogiriHelpers.getNokogiriClass;
+import static nokogiri.internals.NokogiriHelpers.isNamespace;
+import static nokogiri.internals.NokogiriHelpers.stringOrNil;
+import nokogiri.HtmlDocument;
+import nokogiri.NokogiriService;
+import nokogiri.XmlDocument;
+
+import org.apache.xerces.xni.Augmentations;
+import org.apache.xerces.xni.QName;
+import org.apache.xerces.xni.XMLAttributes;
+import org.apache.xerces.xni.XNIException;
+import org.apache.xerces.xni.parser.XMLDocumentFilter;
+import org.apache.xerces.xni.parser.XMLParserConfiguration;
+import org.cyberneko.html.HTMLConfiguration;
+import org.cyberneko.html.filters.DefaultFilter;
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.w3c.dom.Document;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+/**
+ * Parser for HtmlDocument. This class actually parses HtmlDocument using NekoHtml.
+ *
+ * @author sergio
+ * @author Patrick Mahoney
+ * @author Yoko Harada
+ */
+public class HtmlDomParserContext extends XmlDomParserContext {
+
+ public HtmlDomParserContext(Ruby runtime, IRubyObject options) {
+ super(runtime, options);
+ }
+
+ public HtmlDomParserContext(Ruby runtime, IRubyObject encoding, IRubyObject options) {
+ super(runtime, encoding, options);
+ }
+
+ @Override
+ protected void initErrorHandler() {
+ if (options.strict) {
+ errorHandler = new NokogiriStrictErrorHandler(options.noError, options.noWarning);
+ } else {
+ errorHandler = new NokogiriNonStrictErrorHandler4NekoHtml(options.noError, options.noWarning);
+ }
+ }
+
+ @Override
+ protected void initParser(Ruby runtime) {
+ XMLParserConfiguration config = new HTMLConfiguration();
+ //XMLDocumentFilter removeNSAttrsFilter = new RemoveNSAttrsFilter();
+ XMLDocumentFilter elementValidityCheckFilter = new ElementValidityCheckFilter(errorHandler);
+ //XMLDocumentFilter[] filters = { removeNSAttrsFilter, elementValidityCheckFilter};
+ XMLDocumentFilter[] filters = { elementValidityCheckFilter};
+
+ config.setErrorHandler(this.errorHandler);
+
+ parser = new NokogiriDomParser(config);
+
+ // see http://nekohtml.sourceforge.net/settings.html for details
+ setProperty("http://cyberneko.org/html/properties/default-encoding", java_encoding);
+ setProperty("http://cyberneko.org/html/properties/names/elems", "lower");
+ setProperty("http://cyberneko.org/html/properties/names/attrs", "lower");
+ setProperty("http://cyberneko.org/html/properties/filters", filters);
+ setFeature("http://cyberneko.org/html/features/report-errors", true);
+ setFeature("http://xml.org/sax/features/namespaces", false);
+ }
+
+ @Override
+ public void setEncoding(String encoding) {
+ super.setEncoding(encoding);
+ }
+
+ /**
+ * Enable NekoHTML feature for balancing tags in a document fragment.
+ *
+ * This method is used in XmlNode#in_context method.
+ */
+ public void enableDocumentFragment() {
+ setFeature("http://cyberneko.org/html/features/balance-tags/document-fragment", true);
+ }
+
+ @Override
+ protected XmlDocument getNewEmptyDocument(ThreadContext context) {
+ IRubyObject[] args = IRubyObject.NULL_ARRAY;
+ return (XmlDocument) XmlDocument.rbNew(context, getNokogiriClass(context.getRuntime(), "Nokogiri::HTML::Document"), args);
+ }
+
+ @Override
+ protected XmlDocument wrapDocument(ThreadContext context, RubyClass klazz, Document document) {
+ HtmlDocument htmlDocument = (HtmlDocument) NokogiriService.HTML_DOCUMENT_ALLOCATOR.allocate(context.getRuntime(), klazz);
+ htmlDocument.setDocumentNode(context, document);
+ if (ruby_encoding.isNil()) {
+ // ruby_encoding might have detected by HtmlDocument::EncodingReader
+ if (detected_encoding != null && !detected_encoding.isNil()) {
+ ruby_encoding = detected_encoding;
+ } else {
+ // no encoding given & no encoding detected, then try to get it
+ String charset = tryGetCharsetFromHtml5MetaTag(document);
+ ruby_encoding = stringOrNil(context.getRuntime(), charset);
+ }
+ }
+ htmlDocument.setEncoding(ruby_encoding);
+ htmlDocument.setParsedEncoding(java_encoding);
+ return htmlDocument;
+ }
+
+ // NekoHtml doesn't understand HTML5 meta tag format. This fails to detect charset
+ // from an HTML5 style meta tag. Luckily, the meta tag and charset exists in DOM tree
+ // so, this method attempts to find the charset.
+ private static String tryGetCharsetFromHtml5MetaTag(Document document) {
+ if (!"html".equalsIgnoreCase(document.getDocumentElement().getNodeName())) return null;
+ NodeList list = document.getDocumentElement().getChildNodes(); Node item;
+ for (int i = 0; i < list.getLength(); i++) {
+ if ("head".equalsIgnoreCase((item = list.item(i)).getNodeName())) {
+ NodeList headers = item.getChildNodes();
+ for (int j = 0; j < headers.getLength(); j++) {
+ if ("meta".equalsIgnoreCase((item = headers.item(j)).getNodeName())) {
+ NamedNodeMap nodeMap = item.getAttributes();
+ for (int k = 0; k < nodeMap.getLength(); k++) {
+ if ("charset".equalsIgnoreCase((item = nodeMap.item(k)).getNodeName())) {
+ return item.getNodeValue();
+ }
+ }
+ }
+ }
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Filter to strip out attributes that pertain to XML namespaces.
+ */
+ public static class RemoveNSAttrsFilter extends DefaultFilter {
+ @Override
+ public void startElement(QName element, XMLAttributes attrs,
+ Augmentations augs) throws XNIException {
+ int i;
+ for (i = 0; i < attrs.getLength(); ++i) {
+ if (isNamespace(attrs.getQName(i))) {
+ attrs.removeAttributeAt(i);
+ --i;
+ }
+ }
+
+ element.uri = null;
+ super.startElement(element, attrs, augs);
+ }
+ }
+
+ public static class ElementValidityCheckFilter extends DefaultFilter {
+ private NokogiriErrorHandler errorHandler;
+
+ private ElementValidityCheckFilter(NokogiriErrorHandler errorHandler) {
+ this.errorHandler = errorHandler;
+ }
+
+ // element names from xhtml1-strict.dtd
+ private static String[][] element_names = {
+ {"a", "abbr", "acronym", "address", "area"},
+ {"b", "base", "basefont", "bdo", "big", "blockquote", "body", "br", "button"},
+ {"caption", "cite", "code", "col", "colgroup"},
+ {"dd", "del", "dfn", "div", "dl", "dt"},
+ {"em"},
+ {"fieldset", "font", "form", "frame", "frameset"},
+ {}, // g
+ {"h1", "h2", "h3", "h4", "h5", "h6", "head", "hr", "html"},
+ {"i", "iframe", "img", "input", "ins"},
+ {}, // j
+ {"kbd"},
+ {"label", "legend", "li", "link"},
+ {"map", "meta"},
+ {"noframes", "noscript"},
+ {"object", "ol", "optgroup", "option"},
+ {"p", "param", "pre"},
+ {"q"},
+ {}, // r
+ {"s", "samp", "script", "select", "small", "span", "strike", "strong", "style", "sub", "sup"},
+ {"table", "tbody", "td", "textarea", "tfoot", "th", "thead", "title", "tr", "tt"},
+ {"u", "ul"},
+ {"var"},
+ {}, // w
+ {}, // x
+ {}, // y
+ {} // z
+ };
+
+ private static boolean isValid(final String name) {
+ int index = name.charAt(0) - 97;
+ if (index >= element_names.length) return false;
+ String[] elementNames = element_names[index];
+ for (int i=0; i
+ */
+public class NokogiriBlockingQueueInputStream extends InputStream {
+ private final LinkedBlockingQueue queue;
+ protected Task currentTask;
+ protected ByteArrayInputStream currentStream;
+ protected int position;
+ protected boolean closed = false;
+
+ public static final ByteArrayInputStream END = new ByteArrayInputStream(new byte[0]);
+
+ private static class Task extends FutureTask {
+ private final ByteArrayInputStream stream;
+
+ public Task(ByteArrayInputStream stream) {
+ super(new Callable() {
+ @Override
+ public Void call() throws Exception {
+ // TODO Auto-generated method stub
+ return null;
+ }
+ });
+ this.stream = stream;
+ }
+
+ public ByteArrayInputStream getStream() {
+ return stream;
+ }
+
+ @Override
+ public void run() {
+ // don't do anything
+ }
+
+ @Override
+ public boolean runAndReset() {
+ // don't do anything
+ return true;
+ }
+
+ @Override
+ public void set(Void v) {
+ super.set(v);
+ }
+ }
+
+ public NokogiriBlockingQueueInputStream() {
+ queue = new LinkedBlockingQueue();
+ }
+
+ /**
+ * This method shouldn't be called unless the parser has finished parsing or
+ * threw an exception while doing so, otherwise, there'll be the protential
+ * that the read method will block indefinitely.
+ */
+ @Override
+ public synchronized void close() {
+ closed = true;
+ List tasks = new LinkedList();
+ queue.drainTo(tasks);
+ tasks.add(currentTask);
+ for (Task task : tasks) {
+ task.set(null);
+ }
+ }
+
+ /**
+ * Add @param stream to the end of the queue of data that will be returned by
+ * {@link #read()} and its variants. The method will @return a future whose
+ * {@link Future#get()} will block until the data in @param stream is read.
+ *
+ * Passing the special stream {@link #END} to this method, will cause
+ * {@link #read()} to return an eof indicator (i.e. -1) to the caller, after
+ * all the data inserted before {@link #END} is processed.
+ *
+ * @return
+ */
+ public synchronized Future addChunk(ByteArrayInputStream stream) throws ClosedStreamException {
+ if (closed)
+ throw new ClosedStreamException("Cannot add a chunk to a closed stream");
+ Task task = new Task(stream);
+ queue.add(task);
+ return task;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.io.InputStream#read()
+ */
+ @Override
+ public int read() throws IOException {
+ if (currentTask == null || currentStream.available() == 0)
+ if (getNextTask() == -1)
+ return -1;
+ return currentStream.read();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.io.InputStream#read(byte[], int, int)
+ */
+ @Override
+ public int read(byte[] bytes, int off, int len) {
+ if (currentTask == null || currentStream.available() == 0) {
+ if (getNextTask() == -1) {
+ currentTask.set(null);
+ return -1;
+ }
+ }
+ return currentStream.read(bytes, off, len);
+ }
+
+ protected int getNextTask() {
+ while (true) {
+ try {
+ if (currentTask != null)
+ currentTask.set(null);
+ currentTask = queue.take();
+ currentStream = currentTask.getStream();
+ return currentStream.available() == 0 ? -1 : currentStream.available();
+ } catch (InterruptedException ex) {
+ // keep retrying to read
+ }
+ }
+ }
+}
diff -pruN 1.8.4-1/ext/java/nokogiri/internals/NokogiriDomParser.java 1.10.0+dfsg1-2/ext/java/nokogiri/internals/NokogiriDomParser.java
--- 1.8.4-1/ext/java/nokogiri/internals/NokogiriDomParser.java 1970-01-01 00:00:00.000000000 +0000
+++ 1.10.0+dfsg1-2/ext/java/nokogiri/internals/NokogiriDomParser.java 2019-01-04 15:20:12.000000000 +0000
@@ -0,0 +1,116 @@
+/**
+ * (The MIT License)
+ *
+ * Copyright (c) 2008 - 2011:
+ *
+ * * {Aaron Patterson}[http://tenderlovemaking.com]
+ * * {Mike Dalessio}[http://mike.daless.io]
+ * * {Charles Nutter}[http://blog.headius.com]
+ * * {Sergio Arbeo}[http://www.serabe.com]
+ * * {Patrick Mahoney}[http://polycrystal.org]
+ * * {Yoko Harada}[http://yokolet.blogspot.com]
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package nokogiri.internals;
+
+import java.io.IOException;
+
+import nokogiri.XmlDocument;
+
+import org.apache.xerces.parsers.DOMParser;
+import org.apache.xerces.parsers.XIncludeParserConfiguration;
+import org.apache.xerces.xni.parser.XMLParserConfiguration;
+import org.cyberneko.dtd.DTDConfiguration;
+import org.w3c.dom.Document;
+import org.xml.sax.Attributes;
+import org.xml.sax.ContentHandler;
+import org.xml.sax.InputSource;
+import org.xml.sax.Locator;
+import org.xml.sax.SAXException;
+
+/**
+ * Sets up a Xerces/XNI DOM Parser for use with Nokogiri. Uses
+ * NekoDTD to parse the DTD into a tree of Nodes.
+ *
+ * @author Patrick Mahoney
+ */
+public class NokogiriDomParser extends DOMParser {
+ protected DOMParser dtd;
+ protected boolean xInclude;
+ protected XMLParserConfiguration config;
+
+ public NokogiriDomParser(XMLParserConfiguration config) {
+ super(config);
+ this.config = config;
+ initialize();
+ }
+
+ public NokogiriDomParser(ParserContext.Options options) {
+ xInclude = options.xInclude;
+ initialize();
+ }
+
+ protected void initialize() {
+ if (config == null) {
+ if (xInclude) {
+ config = new XIncludeParserConfiguration();
+ } else {
+ config = getXMLParserConfiguration();
+ }
+ }
+
+ DTDConfiguration dtdConfig = new DTDConfiguration();
+ dtd = new DOMParser(dtdConfig);
+
+ config.setDTDHandler(dtdConfig);
+ config.setDTDContentModelHandler(dtdConfig);
+ }
+
+ @Override
+ public void parse(InputSource source) throws SAXException, IOException {
+ dtd.reset();
+ if (xInclude) {
+ setEntityResolver(new NokogiriXInlcudeEntityResolver(source));
+ }
+ super.parse(source);
+ Document doc = getDocument();
+ if (doc == null)
+ throw new RuntimeException("null document");
+
+ doc.setUserData(XmlDocument.DTD_RAW_DOCUMENT, dtd.getDocument(), null);
+ }
+
+ private static class NokogiriXInlcudeEntityResolver implements org.xml.sax.EntityResolver {
+ InputSource source;
+ private NokogiriXInlcudeEntityResolver(InputSource source) {
+ this.source = source;
+ }
+
+ @Override
+ public InputSource resolveEntity(String publicId, String systemId)
+ throws SAXException, IOException {
+ if (systemId != null) source.setSystemId(systemId);
+ if (publicId != null) source.setPublicId(publicId);
+ return source;
+ }
+ }
+}
diff -pruN 1.8.4-1/ext/java/nokogiri/internals/NokogiriEncodingReaderWrapper.java 1.10.0+dfsg1-2/ext/java/nokogiri/internals/NokogiriEncodingReaderWrapper.java
--- 1.8.4-1/ext/java/nokogiri/internals/NokogiriEncodingReaderWrapper.java 1970-01-01 00:00:00.000000000 +0000
+++ 1.10.0+dfsg1-2/ext/java/nokogiri/internals/NokogiriEncodingReaderWrapper.java 2019-01-04 15:20:12.000000000 +0000
@@ -0,0 +1,109 @@
+package nokogiri.internals;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+import org.jruby.Ruby;
+import org.jruby.RubyObject;
+import org.jruby.RubyProcess.Sys;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.javasupport.util.RuntimeHelpers;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
+
+/**
+ * This class wraps the EncodingReader which act like a rewinding input stream,
+ * it tries to read the first 1K of data to detect the encoding, but save
+ * this data in a buffer for the subsequent read. Unfortunately, the EncodingReader
+ * will behave as expected only if encoding was detected, otherwise, the read data
+ * won't be stored and EncodingReader will fallback to read directory from the io stream.
+ * this is kind of lame, since we need to have similar logic in both layers. The alternative
+ * is to implement the encoding detection similar to the way C-Nokogiri does it; it starts
+ * parsing assuming encoding is unknown and if encoding is detected it will throw an exception
+ * causing parsing to stop, in which case we have to intercept the exception and set the encoding.
+ * Also in this case we don't have to restart the parsing since html/document.rb does that for us.
+ *
+ * @author John Shahid
+ *
+ */
+public class NokogiriEncodingReaderWrapper extends InputStream {
+ private final ThreadContext context;
+ private final IRubyObject encodingReader;
+ private final Ruby ruby;
+ private IRubyObject detectedEncoding;
+ private final byte[] firstChunk = new byte[1024];
+ private int firstChunkOff = 0;
+ private int firstChunkLength = 0;
+
+ public NokogiriEncodingReaderWrapper(ThreadContext context, RubyObject encodingReader) {
+ this.context = context;
+ this.encodingReader = encodingReader;
+ this.ruby = context.getRuntime();
+
+ if (!RuntimeHelpers.invoke(context, encodingReader, "respond_to?", ruby.newSymbol("read")).isTrue()
+ || encodingReader.getInstanceVariable("@io") == null) {
+ throw ruby.newArgumentError("Argument doesn't respond to read or doesn't have instance variable @io");
+ }
+ }
+
+ public boolean detectEncoding() {
+ try {
+ firstChunkLength = read(firstChunk);
+ } catch (RaiseException e) {
+ detectedEncoding = e.getException().getInstanceVariable("@found_encoding");
+ return true;
+ }
+ detectedEncoding = context.nil;
+ return false;
+ }
+
+ public IRubyObject getEncoding() {
+ return detectedEncoding;
+ }
+
+ @Override
+ public int read(byte b[]) {
+ return read(b, 0, b.length);
+ }
+
+ @Override
+ public int read(byte b[], int off, int len) {
+ if (b == null) {
+ throw new NullPointerException();
+ } else if (off < 0 || len < 0 || len > b.length - off) {
+ throw new IndexOutOfBoundsException();
+ } else if (len == 0) {
+ return 0;
+ }
+
+ int copyLength = Math.min(firstChunkLength - firstChunkOff, len);
+ if (copyLength > 0) {
+ System.arraycopy(firstChunk, firstChunkOff, b, off, copyLength);
+ len -= copyLength;
+ firstChunkOff += copyLength;
+ }
+
+ if (len <= 0)
+ return copyLength;
+
+ IRubyObject returnValue = encodingReader.callMethod(context, "read", ruby.newFixnum(len));
+ if (returnValue.isNil())
+ return -1;
+
+ ByteList bytes = returnValue.asString().getByteList();
+ int length = bytes.length();
+ System.arraycopy(bytes.unsafeBytes(), bytes.getBegin(), b, off + copyLength, length);
+ return length + copyLength;
+ }
+
+ @Override
+ public int read() {
+ byte[] bytes = new byte[1];
+ int count = read(bytes, 0, 1);
+ if (count < 1)
+ return count;
+ return bytes[0];
+ }
+
+}
diff -pruN 1.8.4-1/ext/java/nokogiri/internals/NokogiriEntityResolver.java 1.10.0+dfsg1-2/ext/java/nokogiri/internals/NokogiriEntityResolver.java
--- 1.8.4-1/ext/java/nokogiri/internals/NokogiriEntityResolver.java 1970-01-01 00:00:00.000000000 +0000
+++ 1.10.0+dfsg1-2/ext/java/nokogiri/internals/NokogiriEntityResolver.java 2019-01-04 15:20:12.000000000 +0000
@@ -0,0 +1,121 @@
+package nokogiri.internals;
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+
+import nokogiri.internals.ParserContext.Options;
+
+import org.jruby.Ruby;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+import org.xml.sax.ext.EntityResolver2;
+
+/**
+ * An entity resolver aware of the fact that the Ruby runtime can
+ * change directory but the JVM cannot. Thus any file based
+ * entity resolution that uses relative paths must be translated
+ * to be relative to the current directory of the Ruby runtime.
+ */
+public class NokogiriEntityResolver implements EntityResolver2 {
+ protected final Ruby runtime;
+ private final NokogiriErrorHandler handler;
+ private final Options options;
+
+ public NokogiriEntityResolver(Ruby runtime, NokogiriErrorHandler handler, Options options) {
+ super();
+ this.runtime = runtime;
+ this.handler = handler;
+ this.options = options;
+ }
+
+ @Override
+ public InputSource getExternalSubset(String name, String baseURI)
+ throws SAXException, IOException {
+ return null;
+ }
+
+ @Override
+ public InputSource resolveEntity(String publicId, String systemId)
+ throws SAXException, IOException {
+ return resolveEntity(runtime, null, publicId, null, systemId);
+ }
+
+ @Override
+ public InputSource resolveEntity(String name,
+ String publicId,
+ String baseURI,
+ String systemId)
+ throws SAXException, IOException {
+ return resolveEntity(runtime, name, publicId, baseURI, systemId);
+ }
+
+ private static File join(String parent, String child) {
+ if (new File(parent).isFile()) {
+ parent = new File(parent).getParent();
+ }
+ return new File(parent, child);
+ }
+
+ private static InputSource emptyInputSource(InputSource source) {
+ source.setByteStream(new ByteArrayInputStream(new byte[0]));
+ return source;
+ }
+
+ private boolean shouldLoadDtd() {
+ return options.dtdLoad || options.dtdValid;
+ }
+
+ private void addError(String errorMessage) {
+ if (handler != null) handler.errors.add(new Exception(errorMessage));
+ }
+
+ /**
+ * Create a file base input source taking into account the current
+ * directory of runtime.
+ * @throws SAXException
+ */
+ protected InputSource resolveEntity(Ruby runtime, String name, String publicId, String baseURI, String systemId)
+ throws IOException, SAXException {
+ InputSource s = new InputSource();
+ if (name.equals("[dtd]") && !shouldLoadDtd()) {
+ return emptyInputSource(s);
+ } else if (!name.equals("[dtd]") && !options.noEnt) {
+ return emptyInputSource(s);
+ }
+ String adjustedSystemId;
+ URI uri = URI.create(systemId);
+ if (options.noNet && uri.getHost() != null) {
+ addError("Attempt to load network entity " + systemId);
+ return emptyInputSource(s);
+ }
+ // if this is a url or absolute file name then use it
+ if (uri.isAbsolute() && !uri.isOpaque()) {
+ adjustedSystemId = uri.toURL().toString();
+ } else if (new File(uri.getPath()).isAbsolute()) {
+ adjustedSystemId = uri.getPath();
+ } else if (baseURI != null) {
+ URI baseuri = URI.create(baseURI);
+ if (options.noNet && baseuri.getHost() != null) {
+ addError("Attempt to load network entity " + systemId);
+ return emptyInputSource(s);
+ }
+ if (baseuri.getHost() == null) {
+ // this is a local file
+ adjustedSystemId = join(baseuri.getPath(), uri.getPath()).getCanonicalPath();
+ } else {
+ // this is a url, then resolve uri using baseuri
+ adjustedSystemId = baseuri.resolve(systemId).toURL().toString();
+ }
+ } else {
+ // baseURI is null we have to use the current working directory to resolve the entity
+ String pwd = runtime.getCurrentDirectory();
+ adjustedSystemId = join(pwd, uri.getPath()).getCanonicalPath();
+ }
+ s.setSystemId(adjustedSystemId);
+ s.setPublicId(publicId);
+ return s;
+ }
+
+}
diff -pruN 1.8.4-1/ext/java/nokogiri/internals/NokogiriErrorHandler.java 1.10.0+dfsg1-2/ext/java/nokogiri/internals/NokogiriErrorHandler.java
--- 1.8.4-1/ext/java/nokogiri/internals/NokogiriErrorHandler.java 1970-01-01 00:00:00.000000000 +0000
+++ 1.10.0+dfsg1-2/ext/java/nokogiri/internals/NokogiriErrorHandler.java 2019-01-04 15:20:12.000000000 +0000
@@ -0,0 +1,69 @@
+/**
+ * (The MIT License)
+ *
+ * Copyright (c) 2008 - 2011:
+ *
+ * * {Aaron Patterson}[http://tenderlovemaking.com]
+ * * {Mike Dalessio}[http://mike.daless.io]
+ * * {Charles Nutter}[http://blog.headius.com]
+ * * {Sergio Arbeo}[http://www.serabe.com]
+ * * {Patrick Mahoney}[http://polycrystal.org]
+ * * {Yoko Harada}[http://yokolet.blogspot.com]
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package nokogiri.internals;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.xerces.xni.parser.XMLErrorHandler;
+import org.xml.sax.ErrorHandler;
+
+/**
+ * Super class of error handlers.
+ *
+ * XMLErrorHandler is used by nokogiri.internals.HtmlDomParserContext since NekoHtml
+ * uses this type of the error handler.
+ *
+ * @author sergio
+ * @author Yoko Harada
+ */
+public abstract class NokogiriErrorHandler implements ErrorHandler, XMLErrorHandler {
+ protected final List errors;
+ protected boolean noerror;
+ protected boolean nowarning;
+
+ public NokogiriErrorHandler(boolean noerror, boolean nowarning) {
+ this.errors = new ArrayList(4);
+ this.noerror = noerror;
+ this.nowarning = nowarning;
+ }
+
+ List getErrors() { return errors; }
+
+ public void addError(Exception ex) { errors.add(ex); }
+
+ protected boolean usesNekoHtml(String domain) {
+ return "http://cyberneko.org/html".equals(domain);
+ }
+
+}
diff -pruN 1.8.4-1/ext/java/nokogiri/internals/NokogiriHandler.java 1.10.0+dfsg1-2/ext/java/nokogiri/internals/NokogiriHandler.java
--- 1.8.4-1/ext/java/nokogiri/internals/NokogiriHandler.java 1970-01-01 00:00:00.000000000 +0000
+++ 1.10.0+dfsg1-2/ext/java/nokogiri/internals/NokogiriHandler.java 2019-01-04 15:20:12.000000000 +0000
@@ -0,0 +1,330 @@
+/**
+ * (The MIT License)
+ *
+ * Copyright (c) 2008 - 2011:
+ *
+ * * {Aaron Patterson}[http://tenderlovemaking.com]
+ * * {Mike Dalessio}[http://mike.daless.io]
+ * * {Charles Nutter}[http://blog.headius.com]
+ * * {Sergio Arbeo}[http://www.serabe.com]
+ * * {Patrick Mahoney}[http://polycrystal.org]
+ * * {Yoko Harada}[http://yokolet.blogspot.com]
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package nokogiri.internals;
+
+import static nokogiri.internals.NokogiriHelpers.getLocalPart;
+import static nokogiri.internals.NokogiriHelpers.getPrefix;
+import static nokogiri.internals.NokogiriHelpers.isNamespace;
+import static nokogiri.internals.NokogiriHelpers.stringOrNil;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.Set;
+
+import nokogiri.XmlSyntaxError;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.javasupport.util.RuntimeHelpers;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.xml.sax.Attributes;
+import org.xml.sax.Locator;
+import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
+import org.xml.sax.ext.DefaultHandler2;
+
+/**
+ * A handler for SAX parsing.
+ *
+ * @author sergio
+ * @author Yoko Harada
+ */
+public class NokogiriHandler extends DefaultHandler2 implements XmlDeclHandler {
+
+ StringBuilder charactersBuilder;
+ private final Ruby runtime;
+ private final RubyClass attrClass;
+ private final IRubyObject object;
+
+ /**
+ * Stores parse errors with the most-recent error last.
+ *
+ * TODO: should these be stored in the document 'errors' array?
+ * Currently only string messages are stored there.
+ */
+ private final LinkedList errors = new LinkedList();
+
+ private Locator locator;
+ private boolean needEmptyAttrCheck;
+
+ public NokogiriHandler(Ruby runtime, IRubyObject object) {
+ assert object != null;
+ this.runtime = runtime;
+ this.attrClass = (RubyClass) runtime.getClassFromPath("Nokogiri::XML::SAX::Parser::Attribute");
+ this.object = object;
+ charactersBuilder = new StringBuilder();
+ String objectName = object.getMetaClass().getName();
+ if ("Nokogiri::HTML::SAX::Parser".equals(objectName)) needEmptyAttrCheck = true;
+ }
+
+ @Override
+ public void skippedEntity(String skippedEntity) {
+ call("error", runtime.newString("Entity '" + skippedEntity + "' not defined\n"));
+ }
+
+ @Override
+ public void setDocumentLocator(Locator locator) {
+ this.locator = locator;
+ }
+
+ @Override
+ public void startDocument() {
+ call("start_document");
+ }
+
+ @Override
+ public void xmlDecl(String version, String encoding, String standalone) {
+ call("xmldecl", stringOrNil(runtime, version), stringOrNil(runtime, encoding), stringOrNil(runtime, standalone));
+ }
+
+ @Override
+ public void endDocument() {
+ populateCharacters();
+ call("end_document");
+ }
+
+ @Override
+ public void processingInstruction(String target, String data) {
+ call("processing_instruction", runtime.newString(target), runtime.newString(data));
+ }
+
+ /*
+ * This calls "start_element_namespace".
+ *
+ * Attributes that define namespaces are passed in a separate
+ * array of [:prefix, :uri] arrays and are not
+ * passed with the other attributes.
+ */
+ @Override
+ public void startElement(String uri, String localName, String qName, Attributes attrs) throws SAXException {
+ final Ruby runtime = this.runtime;
+ final ThreadContext context = runtime.getCurrentContext();
+
+ // for attributes other than namespace attrs
+ RubyArray rubyAttr = RubyArray.newArray(runtime);
+ // for namespace defining attributes
+ RubyArray rubyNSAttr = RubyArray.newArray(runtime);
+
+ boolean fromFragmentHandler = false; // isFromFragmentHandler();
+
+ for (int i = 0; i < attrs.getLength(); i++) {
+ String u = attrs.getURI(i);
+ String qn = attrs.getQName(i);
+ String ln = attrs.getLocalName(i);
+ String val = attrs.getValue(i);
+ String pre;
+
+ pre = getPrefix(qn);
+ if (ln == null || ln.isEmpty()) ln = getLocalPart(qn);
+
+ if (isNamespace(qn) && !fromFragmentHandler) {
+ // I haven't figured the reason out yet, but, in somewhere,
+ // namespace is converted to array in array and cause
+ // TypeError at line 45 in fragment_handler.rb
+ if (ln.equals("xmlns")) ln = null;
+ rubyNSAttr.append( runtime.newArray( stringOrNil(runtime, ln), runtime.newString(val) ) );
+ } else {
+ IRubyObject[] args = null;
+ if (needEmptyAttrCheck) {
+ if (isEmptyAttr(ln)) {
+ args = new IRubyObject[] {
+ stringOrNil(runtime, ln),
+ stringOrNil(runtime, pre),
+ stringOrNil(runtime, u)
+ };
+ }
+ }
+ if (args == null) {
+ args = new IRubyObject[] {
+ stringOrNil(runtime, ln),
+ stringOrNil(runtime, pre),
+ stringOrNil(runtime, u),
+ stringOrNil(runtime, val)
+ };
+ }
+
+ rubyAttr.append( RuntimeHelpers.invoke(context, attrClass, "new", args) );
+ }
+ }
+
+ if (localName == null || localName.isEmpty()) localName = getLocalPart(qName);
+ populateCharacters();
+ call("start_element_namespace",
+ stringOrNil(runtime, localName),
+ rubyAttr,
+ stringOrNil(runtime, getPrefix(qName)),
+ stringOrNil(runtime, uri),
+ rubyNSAttr);
+ }
+
+ static final Set EMPTY_ATTRS;
+ static {
+ final String[] emptyAttrs = {
+ "checked", "compact", "declare", "defer", "disabled", "ismap", "multiple",
+ "noresize", "nohref", "noshade", "nowrap", "readonly", "selected"
+ };
+ EMPTY_ATTRS = new HashSet(Arrays.asList(emptyAttrs));
+ }
+
+ private static boolean isEmptyAttr(String name) {
+ return EMPTY_ATTRS.contains(name);
+ }
+
+ public final Integer getLine() { // -1 if none is available
+ final int line = locator.getLineNumber();
+ return line == -1 ? null : line;
+ }
+
+ public final Integer getColumn() { // -1 if none is available
+ final int column = locator.getColumnNumber();
+ return column == -1 ? null : column - 1;
+ }
+
+ @Override
+ public void endElement(String uri, String localName, String qName) {
+ populateCharacters();
+ call("end_element_namespace",
+ stringOrNil(runtime, localName),
+ stringOrNil(runtime, getPrefix(qName)),
+ stringOrNil(runtime, uri));
+ }
+
+ @Override
+ public void characters(char[] ch, int start, int length) {
+ charactersBuilder.append(ch, start, length);
+ }
+
+ @Override
+ public void comment(char[] ch, int start, int length) {
+ populateCharacters();
+ call("comment", runtime.newString(new String(ch, start, length)));
+ }
+
+ @Override
+ public void startCDATA() {
+ populateCharacters();
+ }
+
+ @Override
+ public void endCDATA() {
+ call("cdata_block", runtime.newString(charactersBuilder.toString()));
+ charactersBuilder.setLength(0);
+ }
+
+ @Override
+ public void error(SAXParseException ex) {
+ try {
+ final String msg = ex.getMessage();
+ call("error", runtime.newString(msg == null ? "" : msg));
+ addError(new RaiseException(XmlSyntaxError.createError(runtime, ex), true));
+ } catch(RaiseException e) {
+ addError(e);
+ }
+ }
+
+ @Override
+ public void fatalError(SAXParseException ex) {
+ try {
+ final String msg = ex.getMessage();
+ call("error", runtime.newString(msg == null ? "" : msg));
+ addError(new RaiseException(XmlSyntaxError.createFatalError(runtime, ex), true));
+
+ } catch(RaiseException e) {
+ addError(e);
+ }
+ }
+
+ @Override
+ public void warning(SAXParseException ex) {
+ final String msg = ex.getMessage();
+ call("warning", runtime.newString(msg == null ? "" : msg));
+ }
+
+ protected synchronized void addError(RaiseException e) {
+ errors.add(e);
+ }
+
+ public synchronized int getErrorCount() {
+ return errors.size();
+ }
+
+ public synchronized RaiseException getLastError() {
+ return errors.getLast();
+ }
+
+ private void call(String methodName) {
+ ThreadContext context = runtime.getCurrentContext();
+ RuntimeHelpers.invoke(context, document(context), methodName);
+ }
+
+ private void call(String methodName, IRubyObject argument) {
+ ThreadContext context = runtime.getCurrentContext();
+ RuntimeHelpers.invoke(context, document(context), methodName, argument);
+ }
+
+ private void call(String methodName, IRubyObject arg1, IRubyObject arg2) {
+ ThreadContext context = runtime.getCurrentContext();
+ RuntimeHelpers.invoke(context, document(context), methodName, arg1, arg2);
+ }
+
+ private void call(String methodName, IRubyObject arg1, IRubyObject arg2, IRubyObject arg3) {
+ ThreadContext context = runtime.getCurrentContext();
+ RuntimeHelpers.invoke(context, document(context), methodName, arg1, arg2, arg3);
+ }
+
+ private void call(String methodName,
+ IRubyObject arg0,
+ IRubyObject arg1,
+ IRubyObject arg2,
+ IRubyObject arg3,
+ IRubyObject arg4) {
+ ThreadContext context = runtime.getCurrentContext();
+ RuntimeHelpers.invoke(context, document(context), methodName, arg0, arg1, arg2, arg3, arg4);
+ }
+
+ private IRubyObject document(ThreadContext context) {
+ return object.getInstanceVariables().getInstanceVariable("@document");
+ }
+
+ protected void populateCharacters() {
+ if (charactersBuilder.length() > 0) {
+ call("characters", runtime.newString(charactersBuilder.toString()));
+ charactersBuilder.setLength(0);
+ }
+ }
+}
diff -pruN 1.8.4-1/ext/java/nokogiri/internals/NokogiriHelpers.java 1.10.0+dfsg1-2/ext/java/nokogiri/internals/NokogiriHelpers.java
--- 1.8.4-1/ext/java/nokogiri/internals/NokogiriHelpers.java 1970-01-01 00:00:00.000000000 +0000
+++ 1.10.0+dfsg1-2/ext/java/nokogiri/internals/NokogiriHelpers.java 2019-01-04 15:20:12.000000000 +0000
@@ -0,0 +1,798 @@
+/**
+ * (The MIT License)
+ *
+ * Copyright (c) 2008 - 2014:
+ *
+ * * {Aaron Patterson}[http://tenderlovemaking.com]
+ * * {Mike Dalessio}[http://mike.daless.io]
+ * * {Charles Nutter}[http://blog.headius.com]
+ * * {Sergio Arbeo}[http://www.serabe.com]
+ * * {Patrick Mahoney}[http://polycrystal.org]
+ * * {Yoko Harada}[http://yokolet.blogspot.com]
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package nokogiri.internals;
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.charset.Charset;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyString;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
+import org.w3c.dom.Attr;
+import org.w3c.dom.DOMException;
+import org.w3c.dom.Document;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+import nokogiri.HtmlDocument;
+import nokogiri.NokogiriService;
+import nokogiri.XmlAttr;
+import nokogiri.XmlCdata;
+import nokogiri.XmlComment;
+import nokogiri.XmlDocument;
+import nokogiri.XmlDtd;
+import nokogiri.XmlElement;
+import nokogiri.XmlEntityReference;
+import nokogiri.XmlNamespace;
+import nokogiri.XmlNode;
+import nokogiri.XmlProcessingInstruction;
+import nokogiri.XmlText;
+import nokogiri.XmlXpathContext;
+
+/**
+ * A class for various utility methods.
+ *
+ * @author serabe
+ * @author Patrick Mahoney
+ * @author Yoko Harada
+ */
+public class NokogiriHelpers {
+ public static final String CACHED_NODE = "NOKOGIRI_CACHED_NODE";
+ public static final String VALID_ROOT_NODE = "NOKOGIRI_VALIDE_ROOT_NODE";
+ public static final String ENCODED_STRING = "NOKOGIRI_ENCODED_STRING";
+
+ public static XmlNode getCachedNode(Node node) {
+ return (XmlNode) node.getUserData(CACHED_NODE);
+ }
+
+ public static void clearCachedNode(Node node) {
+ node.setUserData(CACHED_NODE, null, null);
+ }
+
+ public static void clearXpathContext(Node node) {
+ if (node == null) return;
+
+ Node ownerDocument = node.getOwnerDocument();
+ if (ownerDocument == null) {
+ ownerDocument = node;
+ }
+ ownerDocument.setUserData(XmlXpathContext.XPATH_CONTEXT, null, null);
+ }
+
+ /**
+ * Get the XmlNode associated with the underlying
+ * node. Creates a new XmlNode (or appropriate subclass)
+ * or XmlNamespace wrapping node if there is no cached
+ * value.
+ */
+ public static IRubyObject getCachedNodeOrCreate(Ruby ruby, Node node) {
+ if(node == null) return ruby.getNil();
+ if (node.getNodeType() == Node.ATTRIBUTE_NODE && isNamespace(node.getNodeName())) {
+ XmlDocument xmlDocument = (XmlDocument)node.getOwnerDocument().getUserData(CACHED_NODE);
+ if (!(xmlDocument instanceof HtmlDocument)) {
+ String prefix = getLocalNameForNamespace(((Attr)node).getName());
+ prefix = prefix != null ? prefix : "";
+ String href = ((Attr)node).getValue();
+ XmlNamespace xmlNamespace = xmlDocument.getNamespaceCache().get(prefix, href);
+ if (xmlNamespace != null) return xmlNamespace;
+ else return XmlNamespace.createFromAttr(ruby, (Attr)node);
+ }
+ }
+ XmlNode xmlNode = getCachedNode(node);
+ if(xmlNode == null) {
+ xmlNode = (XmlNode)constructNode(ruby, node);
+ node.setUserData(CACHED_NODE, xmlNode, null);
+ }
+ return xmlNode;
+ }
+
+ /**
+ * Construct a new XmlNode wrapping node. The proper
+ * subclass of XmlNode is chosen based on the type of
+ * node.
+ */
+ public static IRubyObject constructNode(Ruby runtime, Node node) {
+ if (node == null) return runtime.getNil();
+ // this is slow; need a way to cache nokogiri classes/modules somewhere
+ switch (node.getNodeType()) {
+ case Node.ELEMENT_NODE:
+ XmlElement xmlElement = (XmlElement) NokogiriService.XML_ELEMENT_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::Element"));
+ xmlElement.setNode(runtime.getCurrentContext(), node);
+ return xmlElement;
+ case Node.ATTRIBUTE_NODE:
+ XmlAttr xmlAttr = (XmlAttr) NokogiriService.XML_ATTR_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::Attr"));
+ xmlAttr.setNode(runtime.getCurrentContext(), node);
+ return xmlAttr;
+ case Node.TEXT_NODE:
+ XmlText xmlText = (XmlText) NokogiriService.XML_TEXT_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::Text"));
+ xmlText.setNode(runtime.getCurrentContext(), node);
+ return xmlText;
+ case Node.COMMENT_NODE:
+ XmlComment xmlComment = (XmlComment) NokogiriService.XML_COMMENT_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::Comment"));
+ xmlComment.setNode(runtime.getCurrentContext(), node);
+ return xmlComment;
+ case Node.ENTITY_NODE:
+ return new XmlNode(runtime, getNokogiriClass(runtime, "Nokogiri::XML::EntityDecl"), node);
+ case Node.ENTITY_REFERENCE_NODE:
+ XmlEntityReference xmlEntityRef = (XmlEntityReference) NokogiriService.XML_ENTITY_REFERENCE_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::EntityReference"));
+ xmlEntityRef.setNode(runtime.getCurrentContext(), node);
+ return xmlEntityRef;
+ case Node.PROCESSING_INSTRUCTION_NODE:
+ XmlProcessingInstruction xmlProcessingInstruction = (XmlProcessingInstruction) NokogiriService.XML_PROCESSING_INSTRUCTION_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::ProcessingInstruction"));
+ xmlProcessingInstruction.setNode(runtime.getCurrentContext(), node);
+ return xmlProcessingInstruction;
+ case Node.CDATA_SECTION_NODE:
+ XmlCdata xmlCdata = (XmlCdata) NokogiriService.XML_CDATA_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::CDATA"));
+ xmlCdata.setNode(runtime.getCurrentContext(), node);
+ return xmlCdata;
+ case Node.DOCUMENT_NODE:
+ XmlDocument xmlDocument = (XmlDocument) NokogiriService.XML_DOCUMENT_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::Document"));
+ xmlDocument.setDocumentNode(runtime.getCurrentContext(), node);
+ return xmlDocument;
+ case Node.DOCUMENT_TYPE_NODE:
+ XmlDtd xmlDtd = (XmlDtd) NokogiriService.XML_DTD_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::DTD"));
+ xmlDtd.setNode(runtime, node);
+ return xmlDtd;
+ default:
+ XmlNode xmlNode = (XmlNode) NokogiriService.XML_NODE_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::Node"));
+ xmlNode.setNode(runtime.getCurrentContext(), node);
+ return xmlNode;
+ }
+ }
+
+ public static RubyClass getNokogiriClass(Ruby ruby, String name) {
+ return NokogiriService.getNokogiriClassCache(ruby).get(name);
+ }
+
+ public static IRubyObject stringOrNil(Ruby runtime, String str) {
+ return str == null ? runtime.getNil() : convertString(runtime, str);
+ }
+
+ public static IRubyObject stringOrNil(Ruby runtime, CharSequence str) {
+ return str == null ? runtime.getNil() : convertString(runtime, str);
+ }
+
+ public static IRubyObject stringOrNil(Ruby runtime, byte[] bytes) {
+ return bytes == null ? runtime.getNil() : RubyString.newString(runtime, bytes);
+ }
+
+ public static IRubyObject stringOrBlank(Ruby runtime, String str) {
+ return str == null ? runtime.newString() : convertString(runtime, str);
+ }
+
+ public static RubyString convertString(Ruby runtime, String str) {
+ return RubyString.newUTF8String(runtime, str);
+ }
+
+ public static RubyString convertString(Ruby runtime, CharSequence str) {
+ return RubyString.newUTF8String(runtime, str);
+ }
+
+ /**
+ * Convert s to a RubyString, or if s is null or
+ * empty return RubyNil.
+ */
+ public static IRubyObject nonEmptyStringOrNil(Ruby runtime, String s) {
+ if (s == null || s.length() == 0) return runtime.getNil();
+ return RubyString.newString(runtime, s);
+ }
+
+ /**
+ * Return the prefix of a qualified name like "prefix:local".
+ * Returns null if there is no prefix.
+ */
+ public static String getPrefix(String qName) {
+ if (qName == null) return null;
+
+ final int pos = qName.indexOf(':');
+ return pos > 0 ? qName.substring(0, pos) : null;
+ }
+
+ /**
+ * Return the local part of a qualified name like "prefix:local".
+ * Returns qName if there is no prefix.
+ */
+ public static String getLocalPart(String qName) {
+ if (qName == null) return null;
+
+ final int pos = qName.indexOf(':');
+ return pos > 0 ? qName.substring(pos + 1) : qName;
+ }
+
+ public static String getLocalNameForNamespace(String name) {
+ String localName = getLocalPart(name);
+ return ("xmlns".equals(localName)) ? null : localName;
+ }
+
+ private static final Charset UTF8 = Charset.forName("UTF-8");
+
+ /**
+ * Converts a RubyString in to a Java String. Assumes the
+ * RubyString is encoded as UTF-8. This is generally the case for
+ * RubyStrings created with getRuntime().newString("java string").
+ * It also seems to be the case for strings created within Ruby
+ * where $KCODE has not been set.
+ *
+ * Note that RubyString#toString() decodes the string data as
+ * ISO-8859-1 (See org.jruby.util.ByteList.java). This is not
+ * what you want if you have any multibyte characters in your
+ * UTF-8 string.
+ *
+ * FIXME: This really needs to be more robust in terms of
+ * detecting the encoding and properly converting to a Java
+ * String. It's unfortunate that RubyString#toString() doesn't do
+ * this for us.
+ */
+ public static String rubyStringToString(IRubyObject str) {
+ if (str.isNil()) return null;
+ //return rubyStringToString(str.convertToString());
+ return toJavaString(str.convertToString());
+ }
+
+ private static String toJavaString(RubyString str) {
+ return str.decodeString(); // toString()
+ }
+
+ public static String rubyStringToString(RubyString str) {
+ ByteList byteList = str.getByteList();
+ byte[] data = byteList.unsafeBytes();
+ int offset = byteList.begin();
+ int len = byteList.length();
+ ByteBuffer buf = ByteBuffer.wrap(data, offset, len);
+ return UTF8.decode(buf).toString();
+ }
+
+ public static ByteArrayInputStream stringBytesToStream(final IRubyObject str) {
+ if (str instanceof RubyString || str.respondsTo("to_str")) {
+ final ByteList bytes = str.convertToString().getByteList();
+ return new ByteArrayInputStream(bytes.unsafeBytes(), bytes.begin(), bytes.length());
+ }
+ return null;
+ }
+
+ public static String getNodeCompletePath(Node node) {
+
+ Node cur, tmp, next;
+
+ // TODO: Rename buffer to path.
+ String buffer = "";
+
+ cur = node;
+
+ do {
+ String name = "";
+ String sep = "?";
+ int occur = 0;
+ boolean generic = false;
+
+ if(cur.getNodeType() == Node.DOCUMENT_NODE) {
+ if(buffer.startsWith("/")) break;
+
+ sep = "/";
+ next = null;
+ } else if(cur.getNodeType() == Node.ELEMENT_NODE) {
+ generic = false;
+ sep = "/";
+
+ name = cur.getLocalName();
+ if (name == null) name = cur.getNodeName();
+ if(cur.getNamespaceURI() != null) {
+ if(cur.getPrefix() != null) {
+ name = cur.getPrefix() + ":" + name;
+ } else {
+ generic = true;
+ name = "*";
+ }
+ }
+
+ next = cur.getParentNode();
+
+ /*
+ * Thumbler index computation
+ */
+
+ tmp = cur.getPreviousSibling();
+
+ while(tmp != null) {
+ if((tmp.getNodeType() == Node.ELEMENT_NODE) &&
+ (generic || fullNamesMatch(tmp, cur))) {
+ occur++;
+ }
+ tmp = tmp.getPreviousSibling();
+ }
+
+ if(occur == 0) {
+ tmp = cur.getNextSibling();
+
+ while(tmp != null && occur == 0) {
+ if((tmp.getNodeType() == Node.ELEMENT_NODE) &&
+ (generic || fullNamesMatch(tmp,cur))) {
+ occur++;
+ }
+ tmp = tmp.getNextSibling();
+ }
+
+ if(occur != 0) occur = 1;
+
+ } else {
+ occur++;
+ }
+ } else if(cur.getNodeType() == Node.COMMENT_NODE) {
+ sep = "/";
+ name = "comment()";
+ next = cur.getParentNode();
+
+ /*
+ * Thumbler index computation.
+ */
+
+ tmp = cur.getPreviousSibling();
+
+ while(tmp != null) {
+ if(tmp.getNodeType() == Node.COMMENT_NODE) {
+ occur++;
+ }
+ tmp = tmp.getPreviousSibling();
+ }
+
+ if(occur == 0) {
+ tmp = cur.getNextSibling();
+ while(tmp != null && occur == 0) {
+ if(tmp.getNodeType() == Node.COMMENT_NODE) {
+ occur++;
+ }
+ tmp = tmp.getNextSibling();
+ }
+ if(occur != 0) occur = 1;
+ } else {
+ occur = 1;
+ }
+
+ } else if(cur.getNodeType() == Node.TEXT_NODE ||
+ cur.getNodeType() == Node.CDATA_SECTION_NODE) {
+ // I'm here. gist:129
+ // http://gist.github.com/144923
+
+ sep = "/";
+ name = "text()";
+ next = cur.getParentNode();
+
+ /*
+ * Thumbler index computation.
+ */
+
+ tmp = cur.getPreviousSibling();
+ while(tmp != null) {
+ if(tmp.getNodeType() == Node.TEXT_NODE ||
+ tmp.getNodeType() == Node.CDATA_SECTION_NODE) {
+ occur++;
+ }
+ tmp = tmp.getPreviousSibling();
+ }
+
+ if(occur == 0) {
+ tmp = cur.getNextSibling();
+
+ while(tmp != null && occur == 0) {
+ if(tmp.getNodeType() == Node.TEXT_NODE ||
+ tmp.getNodeType() == Node.CDATA_SECTION_NODE) {
+ occur++;
+ }
+ tmp = tmp.getNextSibling();
+ }
+ } else {
+ occur++;
+ }
+
+ } else if(cur.getNodeType() == Node.PROCESSING_INSTRUCTION_NODE) {
+ sep = "/";
+ name = "processing-instruction('"+cur.getLocalName()+"')";
+ next = cur.getParentNode();
+
+ /*
+ * Thumbler index computation.
+ */
+
+ tmp = cur.getParentNode();
+
+ while(tmp != null) {
+ if(tmp.getNodeType() == Node.PROCESSING_INSTRUCTION_NODE &&
+ tmp.getLocalName().equals(cur.getLocalName())) {
+ occur++;
+ }
+ tmp = tmp.getPreviousSibling();
+ }
+
+ if(occur == 0) {
+ tmp = cur.getNextSibling();
+
+ while(tmp != null && occur == 0) {
+ if(tmp.getNodeType() == Node.PROCESSING_INSTRUCTION_NODE &&
+ tmp.getLocalName().equals(cur.getLocalName())){
+ occur++;
+ }
+ tmp = tmp.getNextSibling();
+ }
+
+ if(occur != 0) {
+ occur = 1;
+ }
+
+ } else {
+ occur++;
+ }
+
+ } else if(cur.getNodeType() == Node.ATTRIBUTE_NODE) {
+ sep = "/@";
+ name = cur.getLocalName();
+
+ if(cur.getNamespaceURI() != null) {
+ if(cur.getPrefix() != null) {
+ name = cur.getPrefix() + ":" + name;
+ }
+ }
+
+ next = ((Attr) cur).getOwnerElement();
+
+ } else {
+ next = cur.getParentNode();
+ }
+
+ if(occur == 0){
+ buffer = sep+name+buffer;
+ } else {
+ buffer = sep+name+"["+occur+"]"+buffer;
+ }
+
+ cur = next;
+
+ } while(cur != null);
+
+ return buffer;
+ }
+
+ protected static boolean compareTwoNodes(Node m, Node n) {
+ return nodesAreEqual(m.getLocalName(), n.getLocalName()) &&
+ nodesAreEqual(m.getPrefix(), n.getPrefix());
+ }
+
+ protected static boolean fullNamesMatch(Node a, Node b) {
+ return a.getNodeName().equals(b.getNodeName());
+ }
+
+ protected static String getFullName(Node n) {
+ String lname = n.getLocalName();
+ String prefix = n.getPrefix();
+ if (lname != null) {
+ if (prefix != null)
+ return prefix + ":" + lname;
+ else
+ return lname;
+ } else {
+ return n.getNodeName();
+ }
+ }
+
+ private static boolean nodesAreEqual(Object a, Object b) {
+ return (((a == null) && (b == null)) ||
+ ((a != null) && (b != null) && (b.equals(a))));
+ }
+
+ private static final Pattern encoded_pattern = Pattern.compile("&|>|<|
");
+ private static final String[] encoded = {"&", ">", "<", "
"};
+ private static final Pattern decoded_pattern = Pattern.compile("&|>|<|\r");
+ private static final String[] decoded = {"&", ">", "<", "\r"};
+
+ private static StringBuffer convert(Pattern ptn, CharSequence input, String[] oldChars, String[] newChars) {
+ Matcher matcher = ptn.matcher(input);
+ boolean result = matcher.find();
+ StringBuffer sb = new StringBuffer(input.length() + 8);
+ while (result) {
+ String matched = matcher.group();
+ String replacement = "";
+ for (int i=0; i charsetNames = Charset.availableCharsets().keySet();
+
+ private static String ignoreInvalidEncoding(Ruby runtime, IRubyObject encoding) {
+ String givenEncoding = rubyStringToString(encoding);
+ if (charsetNames.contains(givenEncoding)) return givenEncoding;
+ else return guessEncoding();
+ }
+
+ public static String adjustSystemIdIfNecessary(String currentDir, String scriptFileName, String baseURI, String systemId) {
+ if (systemId == null) return systemId;
+ File file = new File(systemId);
+ if (file.isAbsolute()) return systemId;
+ String path = resolveSystemId(baseURI, systemId);
+ if (path != null) return path;
+ path = resolveSystemId(currentDir, systemId);
+ if (path != null) return path;
+ return resolveSystemId(scriptFileName, systemId);
+ }
+
+ private static String resolveSystemId(String baseName, String systemId) {
+ if (baseName == null || baseName.length() < 1) return null;
+ String parentName;
+ baseName = baseName.replace("%20", " ");
+ File base = new File(baseName);
+ if (base.isDirectory()) parentName = baseName;
+ else parentName = base.getParent();
+ if (parentName == null) return null;
+ if (parentName.toLowerCase().startsWith("file:")) parentName = parentName.substring("file:".length());
+ File dtdFile = new File(parentName + "/" + systemId);
+ if (dtdFile.exists()) return dtdFile.getPath();
+ return null;
+ }
+
+ public static boolean isUTF8(String encoding) {
+ if (encoding == null) return true; // no need to convert encoding
+ return Charset.forName(encoding).compareTo(UTF8) == 0;
+ }
+
+ public static ByteBuffer convertEncoding(Charset output_charset, CharSequence input_string) {
+ return output_charset.encode(CharBuffer.wrap(input_string)); // does replace implicitly on un-mappable characters
+ }
+
+ public static CharSequence convertEncodingByNKFIfNecessary(ThreadContext context, XmlDocument doc, CharSequence str) {
+ if (!(doc instanceof HtmlDocument)) return str;
+ String parsed_encoding = ((HtmlDocument)doc).getPraedEncoding();
+ if (parsed_encoding == null) return str;
+ String ruby_encoding = rubyStringToString(doc.getEncoding());
+ if (ruby_encoding == null) return str;
+ Charset encoding = Charset.forName(ruby_encoding);
+ if (Charset.forName(parsed_encoding).compareTo(encoding) == 0) return str;
+ if (str.length() == 0) return str; // no need to convert
+ return NokogiriHelpers.nkf(context, encoding, str);
+ }
+
+ private static final ByteList _Sw = new ByteList(new byte[] { '-','S','w' }, false);
+ private static final ByteList _Jw = new ByteList(new byte[] { '-','J','w' }, false);
+ private static final ByteList _Ew = new ByteList(new byte[] { '-','E','w' }, false);
+ private static final ByteList _Ww = new ByteList(new byte[] { '-','W','w' }, false);
+
+ // This method is used from HTML documents. HTML meta tag with encoding specification
+ // might appear after non-ascii characters are used. For example, a title tag before
+ // a meta tag. In such a case, Xerces encodes characters in UTF-8 without seeing meta tag.
+ // Nokogiri uses NKF library to convert characters correct encoding. This means the method
+ // works only for JIS/Shift_JIS/EUC-JP.
+ private static CharSequence nkf(ThreadContext context, Charset encoding, CharSequence str) {
+ final Ruby runtime = context.getRuntime();
+ final ByteList opt;
+ if (NokogiriHelpers.shift_jis.compareTo(encoding) == 0) opt = _Sw;
+ else if (NokogiriHelpers.jis.compareTo(encoding) == 0) opt = _Jw;
+ else if (NokogiriHelpers.euc_jp.compareTo(encoding) == 0) opt = _Ew;
+ else opt = _Ww; // should not come here. should be treated before this method.
+
+ Class nkfClass;
+ try {
+ nkfClass = runtime.getClassLoader().loadClass("org.jruby.RubyNKF");
+ } catch (ClassNotFoundException e2) {
+ return str;
+ }
+ Method nkf_method;
+ try {
+ nkf_method = nkfClass.getMethod("nkf", ThreadContext.class, IRubyObject.class, IRubyObject.class, IRubyObject.class);
+ RubyString r_str =
+ (RubyString)nkf_method.invoke(null, context, null, runtime.newString(opt), runtime.newString(str.toString()));
+ return NokogiriHelpers.rubyStringToString(r_str);
+ } catch (SecurityException e) {
+ return str;
+ } catch (NoSuchMethodException e) {
+ return str;
+ } catch (IllegalArgumentException e) {
+ return str;
+ } catch (IllegalAccessException e) {
+ return str;
+ } catch (InvocationTargetException e) {
+ return str;
+ }
+ }
+
+ private static final Charset shift_jis = Charset.forName("Shift_JIS");
+ private static final Charset jis = Charset.forName("ISO-2022-JP");
+ private static final Charset euc_jp = Charset.forName("EUC-JP");
+
+ public static boolean shouldEncode(Node text) {
+ final Boolean encoded = (Boolean) text.getUserData(NokogiriHelpers.ENCODED_STRING);
+ return encoded == null || ! encoded;
+ }
+
+ public static boolean shouldDecode(Node text) {
+ return !shouldEncode(text);
+ }
+
+ public static NokogiriNamespaceCache getNamespaceCacheFormNode(Node n) {
+ XmlDocument xmlDoc = (XmlDocument)getCachedNode(n.getOwnerDocument());
+ return xmlDoc.getNamespaceCache();
+ }
+
+ public static Node renameNode(Node n, String namespaceURI, String qualifiedName) throws DOMException {
+ Document doc = n.getOwnerDocument();
+ NokogiriNamespaceCache nsCache = getNamespaceCacheFormNode(n);
+ Node result = doc.renameNode(n, namespaceURI, qualifiedName);
+ if (result != n) {
+ nsCache.replaceNode(n, result);
+ }
+ return result;
+ }
+}
diff -pruN 1.8.4-1/ext/java/nokogiri/internals/NokogiriNamespaceCache.java 1.10.0+dfsg1-2/ext/java/nokogiri/internals/NokogiriNamespaceCache.java
--- 1.8.4-1/ext/java/nokogiri/internals/NokogiriNamespaceCache.java 1970-01-01 00:00:00.000000000 +0000
+++ 1.10.0+dfsg1-2/ext/java/nokogiri/internals/NokogiriNamespaceCache.java 2019-01-04 15:20:12.000000000 +0000
@@ -0,0 +1,185 @@
+/**
+ * (The MIT License)
+ *
+ * Copyright (c) 2008 - 2014:
+ *
+ * * {Aaron Patterson}[http://tenderlovemaking.com]
+ * * {Mike Dalessio}[http://mike.daless.io]
+ * * {Charles Nutter}[http://blog.headius.com]
+ * * {Sergio Arbeo}[http://www.serabe.com]
+ * * {Patrick Mahoney}[http://polycrystal.org]
+ * * {Yoko Harada}[http://yokolet.blogspot.com]
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package nokogiri.internals;
+
+import static nokogiri.internals.NokogiriHelpers.isNamespace;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import nokogiri.XmlNamespace;
+
+import org.w3c.dom.Attr;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+
+/**
+ * Cache of namespages of each node. XmlDocument has one cache of this class.
+ *
+ * @author sergio
+ * @author Yoko Harada
+ */
+public class NokogiriNamespaceCache {
+
+ private List keys;
+ private Map cache; // pair of the index of a given key and entry
+ private XmlNamespace defaultNamespace = null;
+
+ public NokogiriNamespaceCache() {
+ keys = new ArrayList(); // keys are [prefix, href]
+ cache = new LinkedHashMap();
+ }
+
+ public XmlNamespace getDefault() {
+ return defaultNamespace;
+ }
+
+ private String[] getKey(String prefix, String href) {
+ for (String[] key : keys) {
+ if (key[0].equals(prefix) && key[1].equals(href)) return key;
+ }
+ return null;
+ }
+
+ public XmlNamespace get(String prefix, String href) {
+ // prefix should not be null.
+ // In case of a default namespace, an empty string should be given to prefix argument.
+ if (prefix == null || href == null) return null;
+ String[] key = getKey(prefix, href);
+ if (key != null) {
+ return cache.get(key).namespace;
+ }
+ return null;
+ }
+
+ public XmlNamespace get(Node node, String prefix) {
+ if (prefix == null) return defaultNamespace;
+ for (String[] key : keys) {
+ if (key[0].equals(prefix) && cache.get(key) != null && cache.get(key).isOwner(node)) {
+ return cache.get(key).namespace;
+ }
+ }
+ return null;
+ }
+
+ public List get(String prefix) {
+ List namespaces = new ArrayList();
+ if (prefix == null) {
+ namespaces.add(defaultNamespace);
+ return namespaces;
+ }
+ for (String[] key : keys) {
+ if (key[0].equals(prefix) && cache.get(key) != null) {
+ namespaces.add(cache.get(key).namespace);
+ }
+ }
+ return namespaces;
+ }
+
+ public List get(Node node) {
+ List namespaces = new ArrayList();
+ for (String[] key : keys) {
+ CacheEntry entry = cache.get(key);
+ if (entry.isOwner(node)) {
+ namespaces.add(entry.namespace);
+ }
+ }
+ return namespaces;
+ }
+
+ public void put(XmlNamespace namespace, Node ownerNode) {
+ // prefix should not be null.
+ // In case of a default namespace, an empty string should be given to prefix argument.
+ String prefixString = namespace.getPrefix();
+ String hrefString = namespace.getHref();
+ if (getKey(prefixString, hrefString) != null) return;
+ String[] key = {prefixString, hrefString};
+ keys.add(key);
+ CacheEntry entry = new CacheEntry(namespace, ownerNode);
+ cache.put(key, entry);
+ if ("".equals(prefixString)) defaultNamespace = namespace;
+ }
+
+ public void remove(String prefix, String href) {
+ String[] key = getKey(prefix, href);
+ if (key == null) return;
+ keys.remove(key);
+ cache.remove(key);
+ }
+
+ public void clear() {
+ // removes namespace declarations from node
+ for (String[] key : cache.keySet()) {
+ CacheEntry entry = cache.get(key);
+ NamedNodeMap attributes = entry.ownerNode.getAttributes();
+ for (int j=0; j
+ *
+ */
+public final class NokogiriNamespaceContext implements NamespaceContext {
+
+ public static final String NOKOGIRI_PREFIX = "nokogiri";
+ public static final String NOKOGIRI_URI = "http://www.nokogiri.org/default_ns/ruby/extensions_functions";
+ public static final String NOKOGIRI_TEMPORARY_ROOT_TAG = "nokogiri-temporary-root-tag";
+
+ private final Map register;
+
+ public static NokogiriNamespaceContext create() {
+ return new NokogiriNamespaceContext();
+ }
+
+ private NokogiriNamespaceContext() {
+ register = new HashMap(6, 1);
+ register.put(NOKOGIRI_PREFIX, NOKOGIRI_URI);
+ register.put("xml", "http://www.w3.org/XML/1998/namespace");
+ register.put("xhtml", "http://www.w3.org/1999/xhtml");
+ }
+
+ public String getNamespaceURI(String prefix) {
+ if (prefix == null) {
+ throw new IllegalArgumentException();
+ }
+ String uri = this.register.get(prefix);
+ if (uri != null) {
+ return uri;
+ }
+
+ if (prefix.equals(XMLConstants.XMLNS_ATTRIBUTE)) {
+ uri = this.register.get(XMLConstants.XMLNS_ATTRIBUTE);
+ return (uri == null) ? XMLConstants.XMLNS_ATTRIBUTE_NS_URI : uri;
+ }
+
+ return XMLConstants.NULL_NS_URI;
+ }
+
+ public String getPrefix(String uri) {
+ if (uri == null) {
+ throw new IllegalArgumentException("uri is null");
+ }
+ Set> entries = register.entrySet();
+ for (Entry entry : entries) {
+ if (uri.equals(entry.getValue())) {
+ return entry.getKey();
+ }
+ }
+ return null;
+ }
+
+ public Iterator getPrefixes(String uri) {
+ Set> entries = register.entrySet();
+ ArrayList list = new ArrayList(entries.size());
+ for (Entry entry : entries) {
+ if (uri.equals(entry.getValue())) {
+ list.add(entry.getKey());
+ }
+ }
+ return list.iterator();
+ }
+
+ public Set getAllPrefixes() {
+ return register.keySet();
+ }
+
+ public void registerNamespace(String prefix, String uri) {
+ if ("xmlns".equals(prefix)) prefix = "";
+ register.put(prefix, uri);
+ }
+
+}
diff -pruN 1.8.4-1/ext/java/nokogiri/internals/NokogiriNonStrictErrorHandler4NekoHtml.java 1.10.0+dfsg1-2/ext/java/nokogiri/internals/NokogiriNonStrictErrorHandler4NekoHtml.java
--- 1.8.4-1/ext/java/nokogiri/internals/NokogiriNonStrictErrorHandler4NekoHtml.java 1970-01-01 00:00:00.000000000 +0000
+++ 1.10.0+dfsg1-2/ext/java/nokogiri/internals/NokogiriNonStrictErrorHandler4NekoHtml.java 2019-01-04 15:20:12.000000000 +0000
@@ -0,0 +1,121 @@
+/**
+ * (The MIT License)
+ *
+ * Copyright (c) 2008 - 2011:
+ *
+ * * {Aaron Patterson}[http://tenderlovemaking.com]
+ * * {Mike Dalessio}[http://mike.daless.io]
+ * * {Charles Nutter}[http://blog.headius.com]
+ * * {Sergio Arbeo}[http://www.serabe.com]
+ * * {Patrick Mahoney}[http://polycrystal.org]
+ * * {Yoko Harada}[http://yokolet.blogspot.com]
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package nokogiri.internals;
+
+import org.apache.xerces.xni.parser.XMLParseException;
+import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
+
+/**
+ * Non-strict error handler for NekoHtml.
+ *
+ * NekoHtml adds too many warnings, which makes later processing hard. For example,
+ * Nokogiri wants to know whether number of errors have been increased or not to judge
+ * availability of creating NodeSet from a given fragment. When the fragment nodes
+ * are to be created from HTML document, which means NekoHtml is used, always errors
+ * increases. As a result, even though the given fragment is correct HTML, NodeSet
+ * base on the given fragment won't be created. This is why all warnings are eliminated.
+ *
+ * @author Yoko Harada
+ */
+public class NokogiriNonStrictErrorHandler4NekoHtml extends NokogiriErrorHandler {
+
+ public NokogiriNonStrictErrorHandler4NekoHtml(boolean nowarning) {
+ super(false, nowarning);
+ }
+
+ public NokogiriNonStrictErrorHandler4NekoHtml(boolean noerror, boolean nowarning) {
+ super(noerror, nowarning);
+ }
+
+ public void warning(SAXParseException ex) throws SAXException {
+ //noop. NekoHtml adds too many warnings.
+ }
+
+ public void error(SAXParseException ex) throws SAXException {
+ errors.add(ex);
+ }
+
+ public void fatalError(SAXParseException ex) throws SAXException {
+ errors.add(ex);
+ }
+
+ /**
+ * Implementation of org.apache.xerces.xni.parser.XMLErrorHandler. This method
+ * is invoked during parsing fired by HtmlDomParserContext and is a NekoHtml requirement.
+ *
+ * @param domain The domain of the error. The domain can be any string but is
+ * suggested to be a valid URI. The domain can be used to conveniently
+ * specify a web site location of the relevant specification or
+ * document pertaining to this warning.
+ * @param key The error key. This key can be any string and is implementation
+ * dependent.
+ * @param e Exception.
+ */
+ public void error(String domain, String key, XMLParseException e) {
+ errors.add(e);
+ }
+
+ /**
+ * Implementation of org.apache.xerces.xni.parser.XMLErrorHandler. This method
+ * is invoked during parsing fired by HtmlDomParserContext and is a NekoHtml requirement.
+ *
+ * @param domain The domain of the fatal error. The domain can be any string but is
+ * suggested to be a valid URI. The domain can be used to conveniently
+ * specify a web site location of the relevant specification or
+ * document pertaining to this warning.
+ * @param key The fatal error key. This key can be any string and is implementation
+ * dependent.
+ * @param e Exception.
+ */
+ public void fatalError(String domain, String key, XMLParseException e) {
+ errors.add(e);
+ }
+
+ /**
+ * Implementation of org.apache.xerces.xni.parser.XMLErrorHandler. This method
+ * is invoked during parsing fired by HtmlDomParserContext and is a NekoHtml requirement.
+ *
+ * @param domain The domain of the warning. The domain can be any string but is
+ * suggested to be a valid URI. The domain can be used to conveniently
+ * specify a web site location of the relevant specification or
+ * document pertaining to this warning.
+ * @param key The warning key. This key can be any string and is implementation
+ * dependent.
+ * @param e Exception.
+ */
+ public void warning(String domain, String key, XMLParseException e) {
+ errors.add(e);
+ }
+
+}
diff -pruN 1.8.4-1/ext/java/nokogiri/internals/NokogiriNonStrictErrorHandler.java 1.10.0+dfsg1-2/ext/java/nokogiri/internals/NokogiriNonStrictErrorHandler.java
--- 1.8.4-1/ext/java/nokogiri/internals/NokogiriNonStrictErrorHandler.java 1970-01-01 00:00:00.000000000 +0000
+++ 1.10.0+dfsg1-2/ext/java/nokogiri/internals/NokogiriNonStrictErrorHandler.java 2019-01-04 15:20:12.000000000 +0000
@@ -0,0 +1,100 @@
+/**
+ * (The MIT License)
+ *
+ * Copyright (c) 2008 - 2011:
+ *
+ * * {Aaron Patterson}[http://tenderlovemaking.com]
+ * * {Mike Dalessio}[http://mike.daless.io]
+ * * {Charles Nutter}[http://blog.headius.com]
+ * * {Sergio Arbeo}[http://www.serabe.com]
+ * * {Patrick Mahoney}[http://polycrystal.org]
+ * * {Yoko Harada}[http://yokolet.blogspot.com]
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package nokogiri.internals;
+
+import org.apache.xerces.xni.parser.XMLParseException;
+import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
+
+/**
+ * Error Handler for XML document when recover is true (default).
+ *
+ * @author sergio
+ * @author Yoko Harada
+ */
+public class NokogiriNonStrictErrorHandler extends NokogiriErrorHandler{
+ public NokogiriNonStrictErrorHandler(boolean noerror, boolean nowarning) {
+ super(noerror, nowarning);
+ }
+
+ public void warning(SAXParseException ex) throws SAXException {
+ errors.add(ex);
+ }
+
+ public void error(SAXParseException ex) throws SAXException {
+ errors.add(ex);
+ }
+
+ public void fatalError(SAXParseException ex) throws SAXException {
+ // fix #837
+ // Xerces won't skip the reference entity (and other invalid) constructs
+ // found in the prolog, instead it will keep calling this method and we'll
+ // keep inserting the error in the document errors array until we run
+ // out of memory
+ errors.add(ex);
+ String message = ex.getMessage();
+
+ // The problem with Xerces is that some errors will cause the
+ // parser not to advance the reader and it will keep reporting
+ // the same error over and over, which will cause the parser
+ // to enter an infinite loop unless we throw the exception.
+ if (message != null && isFatal(message)) {
+ throw ex;
+ }
+ }
+
+ public void error(String domain, String key, XMLParseException e) {
+ errors.add(e);
+ }
+
+ public void fatalError(String domain, String key, XMLParseException e) {
+ errors.add(e);
+ }
+
+ public void warning(String domain, String key, XMLParseException e) {
+ errors.add(e);
+ }
+
+ /*
+ * Determine whether this is a fatal error that should cause
+ * the parsing to stop, or an error that can be ignored.
+ */
+ private static boolean isFatal(String msg) {
+ String msgLowerCase = msg.toLowerCase();
+ return
+ msgLowerCase.contains("in prolog") ||
+ msgLowerCase.contains("limit") ||
+ msgLowerCase.contains("preceding the root element must be well-formed") ||
+ msgLowerCase.contains("following the root element must be well-formed");
+ }
+}
diff -pruN 1.8.4-1/ext/java/nokogiri/internals/NokogiriStrictErrorHandler.java 1.10.0+dfsg1-2/ext/java/nokogiri/internals/NokogiriStrictErrorHandler.java
--- 1.8.4-1/ext/java/nokogiri/internals/NokogiriStrictErrorHandler.java 1970-01-01 00:00:00.000000000 +0000
+++ 1.10.0+dfsg1-2/ext/java/nokogiri/internals/NokogiriStrictErrorHandler.java 2019-01-04 15:20:12.000000000 +0000
@@ -0,0 +1,78 @@
+/**
+ * (The MIT License)
+ *
+ * Copyright (c) 2008 - 2011:
+ *
+ * * {Aaron Patterson}[http://tenderlovemaking.com]
+ * * {Mike Dalessio}[http://mike.daless.io]
+ * * {Charles Nutter}[http://blog.headius.com]
+ * * {Sergio Arbeo}[http://www.serabe.com]
+ * * {Patrick Mahoney}[http://polycrystal.org]
+ * * {Yoko Harada}[http://yokolet.blogspot.com]
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package nokogiri.internals;
+
+import org.apache.xerces.xni.parser.XMLParseException;
+import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
+
+/**
+ * Strict error handler. Even though strict is specified, Nokogiri allows to go further
+ * when NOERROR or/both NOWARNING is/are true.
+ *
+ * @author sergio
+ * @author Yoko Harada
+ */
+public class NokogiriStrictErrorHandler extends NokogiriErrorHandler {
+ public NokogiriStrictErrorHandler(boolean noerror, boolean nowarning) {
+ super(noerror, nowarning);
+ }
+
+ public void warning(SAXParseException spex) throws SAXException {
+ if (!nowarning) throw spex;
+ else errors.add(spex);
+ }
+
+ public void error(SAXParseException spex) throws SAXException {
+ if (!noerror) throw spex;
+ else errors.add(spex);
+ }
+
+ public void fatalError(SAXParseException spex) throws SAXException {
+ throw spex;
+ }
+
+ public void error(String domain, String key, XMLParseException e) throws XMLParseException {
+ if (!noerror) throw e;
+ else errors.add(e);
+ }
+
+ public void fatalError(String domain, String key, XMLParseException e) throws XMLParseException {
+ throw e;
+ }
+
+ public void warning(String domain, String key, XMLParseException e) throws XMLParseException {
+ if (!nowarning) throw e;
+ if (!usesNekoHtml(domain)) errors.add(e);
+ }
+}
diff -pruN 1.8.4-1/ext/java/nokogiri/internals/NokogiriXPathFunction.java 1.10.0+dfsg1-2/ext/java/nokogiri/internals/NokogiriXPathFunction.java
--- 1.8.4-1/ext/java/nokogiri/internals/NokogiriXPathFunction.java 1970-01-01 00:00:00.000000000 +0000
+++ 1.10.0+dfsg1-2/ext/java/nokogiri/internals/NokogiriXPathFunction.java 2019-01-04 15:20:12.000000000 +0000
@@ -0,0 +1,123 @@
+/**
+ * (The MIT License)
+ *
+ * Copyright (c) 2008 - 2011:
+ *
+ * * {Aaron Patterson}[http://tenderlovemaking.com]
+ * * {Mike Dalessio}[http://mike.daless.io]
+ * * {Charles Nutter}[http://blog.headius.com]
+ * * {Sergio Arbeo}[http://www.serabe.com]
+ * * {Patrick Mahoney}[http://polycrystal.org]
+ * * {Yoko Harada}[http://yokolet.blogspot.com]
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package nokogiri.internals;
+
+import java.util.List;
+
+import javax.xml.xpath.XPathFunction;
+import javax.xml.xpath.XPathFunctionException;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyBoolean;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyFloat;
+import org.jruby.RubyInteger;
+import org.jruby.RubyString;
+import org.jruby.javasupport.JavaUtil;
+import org.jruby.javasupport.util.RuntimeHelpers;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.w3c.dom.NodeList;
+
+import nokogiri.XmlNode;
+import nokogiri.XmlNodeSet;
+
+/**
+ * Xpath function handler.
+ *
+ * @author sergio
+ * @author Yoko Harada
+ */
+public class NokogiriXPathFunction implements XPathFunction {
+
+ private final IRubyObject handler;
+ private final String name;
+ private final int arity;
+
+ public static NokogiriXPathFunction create(IRubyObject handler, String name, int arity) {
+ return new NokogiriXPathFunction(handler, name, arity);
+ }
+
+ private NokogiriXPathFunction(IRubyObject handler, String name, int arity) {
+ this.handler = handler;
+ this.name = name;
+ this.arity = arity;
+ }
+
+ public Object evaluate(List args) throws XPathFunctionException {
+ if (args.size() != this.arity) {
+ throw new XPathFunctionException("arity does not match");
+ }
+
+ final Ruby runtime = this.handler.getRuntime();
+ ThreadContext context = runtime.getCurrentContext();
+
+ IRubyObject result = RuntimeHelpers.invoke(context, this.handler, this.name, fromObjectToRubyArgs(runtime, args));
+
+ return fromRubyToObject(runtime, result);
+ }
+
+ private static IRubyObject[] fromObjectToRubyArgs(final Ruby runtime, List args) {
+ IRubyObject[] newArgs = new IRubyObject[args.size()];
+ for(int i = 0; i < args.size(); i++) {
+ newArgs[i] = fromObjectToRuby(runtime, args.get(i));
+ }
+ return newArgs;
+ }
+
+ private static IRubyObject fromObjectToRuby(final Ruby runtime, Object obj) {
+ // argument object type is one of NodeList, String, Boolean, or Double.
+ if (obj instanceof NodeList) {
+ XmlNodeSet xmlNodeSet = XmlNodeSet.newEmptyNodeSet(runtime.getCurrentContext());
+ xmlNodeSet.setNodeList((NodeList) obj);
+ return xmlNodeSet;
+ }
+ return JavaUtil.convertJavaToUsableRubyObject(runtime, obj);
+ }
+
+ private static Object fromRubyToObject(final Ruby runtime, IRubyObject obj) {
+ if (obj instanceof RubyString) return obj.asJavaString();
+ if (obj instanceof RubyBoolean) return obj.toJava(Boolean.class);
+ if (obj instanceof RubyFloat) return obj.toJava(Double.class);
+ if (obj instanceof RubyInteger) {
+ if ( obj instanceof RubyFixnum ) return RubyFixnum.fix2long(obj);
+ return obj.toJava(java.math.BigInteger.class);
+ }
+ if (obj instanceof XmlNodeSet) return obj;
+ if (obj instanceof RubyArray) {
+ return XmlNodeSet.newXmlNodeSet(runtime.getCurrentContext(), ((RubyArray) obj).toJavaArray());
+ }
+ /*if (o instanceof XmlNode)*/ return ((XmlNode) obj).getNode();
+ }
+}
diff -pruN 1.8.4-1/ext/java/nokogiri/internals/NokogiriXPathFunctionResolver.java 1.10.0+dfsg1-2/ext/java/nokogiri/internals/NokogiriXPathFunctionResolver.java
--- 1.8.4-1/ext/java/nokogiri/internals/NokogiriXPathFunctionResolver.java 1970-01-01 00:00:00.000000000 +0000
+++ 1.10.0+dfsg1-2/ext/java/nokogiri/internals/NokogiriXPathFunctionResolver.java 2019-01-04 15:20:12.000000000 +0000
@@ -0,0 +1,70 @@
+/**
+ * (The MIT License)
+ *
+ * Copyright (c) 2008 - 2011:
+ *
+ * * {Aaron Patterson}[http://tenderlovemaking.com]
+ * * {Mike Dalessio}[http://mike.daless.io]
+ * * {Charles Nutter}[http://blog.headius.com]
+ * * {Sergio Arbeo}[http://www.serabe.com]
+ * * {Patrick Mahoney}[http://polycrystal.org]
+ * * {Yoko Harada}[http://yokolet.blogspot.com]
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package nokogiri.internals;
+
+import javax.xml.namespace.QName;
+import javax.xml.xpath.XPathFunction;
+import javax.xml.xpath.XPathFunctionResolver;
+
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ * Xpath function resolver class, which is used in XmlXpathContext.
+ *
+ * @author sergio
+ * @author Yoko Harada