nokogiri 1.7.2-java → 1.8.0-java

data/ext/java/nokogiri/internals/SaveContextVisitor.java

@@ -32,21 +32,14 @@
 
 package nokogiri.internals;
 
-import static nokogiri.internals.NokogiriHelpers.canonicalizeWhitespce;
+import static nokogiri.internals.NokogiriHelpers.canonicalizeWhitespace;
 import static nokogiri.internals.NokogiriHelpers.encodeJavaString;
 import static nokogiri.internals.NokogiriHelpers.isNamespace;
 import static nokogiri.internals.NokogiriHelpers.isWhitespaceText;
 
 import java.nio.charset.Charset;
 import java.nio.charset.CharsetEncoder;
-import java.util.ArrayDeque;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Comparator;
-import java.util.Deque;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Stack;
+import java.util.*;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
@@ -74,10 +67,10 @@ import org.w3c.dom.Text;
  */
 public class SaveContextVisitor {
 
-    private final StringBuffer buffer;
+    private final StringBuilder buffer;
     private final Stack<String> indentation;
     private String encoding;
-    private final String indentString;
+    private final CharSequence indentString;
     private boolean format;
     private final boolean noDecl;
     private final boolean noEmpty;
@@ -94,7 +87,8 @@ public class SaveContextVisitor {
     private final List<Node> c14nNodeList;
     private final Deque<Attr[]> c14nNamespaceStack;
     private final Deque<Attr[]> c14nAttrStack;
-    private List<String> c14nExclusiveInclusivePrefixes = null;
+    //private List<String> c14nExclusiveInclusivePrefixes = null;
+
     /*
      * U can't touch this.
      * http://www.youtube.com/watch?v=WJ2ZFVx6A4Q
@@ -117,8 +111,8 @@ public class SaveContextVisitor {
     public static final int SUBSETS = 8;
     public static final int EXCLUSIVE = 16;
 
-    public SaveContextVisitor(int options, String indent, String encoding, boolean htmlDoc, boolean fragment, int canonicalOpts) {
-        buffer = new StringBuffer();
+    public SaveContextVisitor(int options, CharSequence indent, String encoding, boolean htmlDoc, boolean fragment, int canonicalOpts) {
+        buffer = new StringBuilder();
         this.encoding = encoding;
         indentation = new Stack<String>(); indentation.push("");
         this.htmlDoc = htmlDoc;
@@ -150,9 +144,11 @@ public class SaveContextVisitor {
 
     @Override
     public String toString() {
-        return (new String(buffer));
+        return buffer.toString();
     }
 
+    public StringBuilder getInternalBuffer() { return buffer; }
+
     public void setHtmlDoc(boolean htmlDoc) {
         this.htmlDoc = htmlDoc;
     }
@@ -161,14 +157,6 @@ public class SaveContextVisitor {
         this.encoding = encoding;
     }
 
-    public List<Node> getC14nNodeList() {
-        return c14nNodeList;
-    }
-
-   public void setC14nExclusiveInclusivePrefixes(List<String> prefixes) {
-       c14nExclusiveInclusivePrefixes = prefixes;
-   }
-
     public boolean enter(Node node) {
         if (node instanceof Document) {
             return enter((Document)node);
@@ -265,16 +253,16 @@ public class SaveContextVisitor {
         String name = attr.getName();
         buffer.append(name);
         if (!asHtml || !isHtmlBooleanAttr(name)) {
-            buffer.append("=");
-            buffer.append("\"");
+            buffer.append('=');
+            buffer.append('"');
             String value = replaceCharsetIfNecessary(attr);
             buffer.append(serializeAttrTextContent(value, htmlDoc));
-            buffer.append("\"");
+            buffer.append('"');
         }
         return true;
     }
 
-    private static Pattern p =
+    private static final Pattern CHARSET =
         Pattern.compile("charset(()|\\s+)=(()|\\s+)(\\w|\\_|\\.|\\-)+", Pattern.CASE_INSENSITIVE);
 
     private String replaceCharsetIfNecessary(Attr attr) {
@@ -282,47 +270,47 @@ public class SaveContextVisitor {
         if (encoding == null) return value;   // unable to replace in any case
         if (!"content".equals(attr.getName().toLowerCase())) return value;  // must be content attr
         if (!"meta".equals(attr.getOwnerElement().getNodeName().toLowerCase())) return value;
-        Matcher m = p.matcher(value);
+        Matcher m = CHARSET.matcher(value);
         if (!m.find()) return value;
         if (value.contains(encoding)) return value;  // no need to replace
         return value.replace(m.group(), "charset=" + encoding);
     }
 
-    public static final String[] HTML_BOOLEAN_ATTRS = {
-        "checked", "compact", "declare", "defer", "disabled", "ismap",
-        "multiple", "nohref", "noresize", "noshade", "nowrap", "readonly",
-        "selected"
-    };
+    static final Set<String> HTML_BOOLEAN_ATTRS;
+    static {
+        final String[] _HTML_BOOLEAN_ATTRS = {
+            "checked", "compact", "declare", "defer", "disabled", "ismap",
+            "multiple", "nohref", "noresize", "noshade", "nowrap", "readonly",
+            "selected"
+        };
+        HTML_BOOLEAN_ATTRS = new HashSet<String>(Arrays.asList(_HTML_BOOLEAN_ATTRS));
+    }
 
-    private boolean isHtmlBooleanAttr(String name) {
-        for (String s : HTML_BOOLEAN_ATTRS) {
-            if (s.equals(name)) return true;
-        }
-        return false;
+    private static boolean isHtmlBooleanAttr(String name) {
+        return HTML_BOOLEAN_ATTRS.contains(name);
     }
 
-    private String serializeAttrTextContent(String s, boolean htmlDoc) {
-        if (s == null) return "";
+    private static CharSequence serializeAttrTextContent(String str, boolean htmlDoc) {
+        if (str == null || str.length() == 0) return "";
 
-        char[] c = s.toCharArray();
-        StringBuffer buffer = new StringBuffer(c.length);
+        StringBuilder buffer = new StringBuilder(str.length() + 16);
 
-        for(int i = 0; i < c.length; i++) {
-            switch(c[i]){
-            case '\n': buffer.append("&#10;"); break;
-            case '\r': buffer.append("&#13;"); break;
-            case '\t': buffer.append("&#9;"); break;
-            case '"': if (htmlDoc) buffer.append("%22");
+        for (int i = 0; i < str.length(); i++) {
+            char c; switch (c = str.charAt(i)) {
+                case '\n': buffer.append("&#10;"); break;
+                case '\r': buffer.append("&#13;"); break;
+                case '\t': buffer.append("&#9;"); break;
+                case '"': if (htmlDoc) buffer.append("%22");
                 else buffer.append("&quot;");
-                break;
-            case '<': buffer.append("&lt;"); break;
-            case '>': buffer.append("&gt;"); break;
-            case '&': buffer.append("&amp;"); break;
-            default: buffer.append(c[i]);
+                    break;
+                case '<': buffer.append("&lt;"); break;
+                case '>': buffer.append("&gt;"); break;
+                case '&': buffer.append("&amp;"); break;
+                default: buffer.append(c);
             }
         }
 
-        return buffer.toString();
+        return buffer;
     }
 
     public void leave(Attr attr) {
@@ -385,19 +373,19 @@ public class SaveContextVisitor {
         String sysId = docType.getSystemId();
         String internalSubset = docType.getInternalSubset();
         if (docType.getPreviousSibling() != null) {
-            buffer.append("\n");
+            buffer.append('\n');
         }
-        buffer.append("<!DOCTYPE " + name + " ");
+        buffer.append("<!DOCTYPE ").append(name).append(' ');
         if (pubId != null) {
-            buffer.append("PUBLIC \"" + pubId + "\"");
-            if (sysId != null) buffer.append(" \"" + sysId + "\"");
+            buffer.append("PUBLIC \"").append(pubId).append('"');
+            if (sysId != null) buffer.append(" \"").append(sysId).append('"');
         } else if (sysId != null) {
-            buffer.append("SYSTEM \"" + sysId + "\"");
+            buffer.append("SYSTEM \"").append(sysId).append('"');
         }
         if (internalSubset != null) {
-            buffer.append(" [");
+            buffer.append(' ').append('[');
             buffer.append(internalSubset);
-            buffer.append("]");
+            buffer.append(']');
         }
         buffer.append(">\n");
         return true;
@@ -420,36 +408,36 @@ public class SaveContextVisitor {
             indentation.push(current + indentString);
         }
         String name = element.getTagName();
-        buffer.append("<" + name);
+        buffer.append('<').append(name);
         Attr[] attrs = getAttrsAndNamespaces(element);
         for (Attr attr : attrs) {
             if (attr.getSpecified()) {
-                buffer.append(" ");
+                buffer.append(' ');
                 enter(attr);
                 leave(attr);
             }
         }
         if (element.hasChildNodes()) {
-            buffer.append(">");
-            if (needBreakInOpening(element)) buffer.append("\n");
+            buffer.append('>');
+            if (needBreakInOpening(element)) buffer.append('\n');
             return true;
         }
         // no child
         if (asHtml) {
-            buffer.append(">");
+            buffer.append('>');
         } else if (asXml && noEmpty) {
-            buffer.append(">");
+            buffer.append('>');
         } else if (asXhtml) {
             if (isEmpty(name)) {
                 buffer.append(" />"); // see http://www.w3.org/TR/xhtml1/#C_2
             } else {
-                buffer.append(">");
+                buffer.append('>');
             }
         } else {
             buffer.append("/>");
         }
         if (needBreakInOpening(element)) {
-            buffer.append("\n");
+            buffer.append('\n');
         }
         return true;
     }
@@ -619,21 +607,21 @@ public class SaveContextVisitor {
             } else if (asBuilder) {
                 if (!containsText(element)) indentation.pop();
             }
-            buffer.append("</" + name + ">");
+            buffer.append("</").append(name).append('>');
             if (needBreakInClosing(element)) {
-                buffer.append("\n");
+                buffer.append('\n');
             }
             return;
         }
         // no child, but HTML might need a closing tag.
         if (asHtml || noEmpty) {
             if (!isEmpty(name) && noEmpty) {
-                buffer.append("</" + name + ">");
+                buffer.append("</").append(name).append('>');
             }
         }
         if (needBreakInClosing(element)) {
             if (!containsText(element)) indentation.pop();
-            buffer.append("\n");
+            buffer.append('\n');
         }
     }
 
@@ -686,7 +674,7 @@ public class SaveContextVisitor {
     }
 
     public boolean enter(EntityReference entityRef) {
-        buffer.append("&" + entityRef.getNodeName() + ";");
+        buffer.append('&').append(entityRef.getNodeName()).append(';');
         return true;
     }
     public void leave(EntityReference entityRef) {
@@ -738,20 +726,19 @@ public class SaveContextVisitor {
     }
 
     private boolean isHtmlScript(Text text) {
-      return htmlDoc && text.getParentNode().getNodeName().equals("script");
+        return htmlDoc && text.getParentNode().getNodeName().equals("script");
     }
 
     private boolean isHtmlStyle(Text text) {
-      return htmlDoc && text.getParentNode().getNodeName().equals("style");
+        return htmlDoc && text.getParentNode().getNodeName().equals("style");
     }
 
-    private static char lineSeparator = '\n'; // System.getProperty("line.separator"); ?
     public boolean enter(Text text) {
-        String textContent = text.getNodeValue();
+        CharSequence textContent = text.getNodeValue();
         if (canonical) {
             c14nNodeList.add(text);
             if (isWhitespaceText(textContent)) {
-                buffer.append(canonicalizeWhitespce(textContent));
+                buffer.append(canonicalizeWhitespace(textContent));
                 return true;
             }
         }
@@ -765,25 +752,26 @@ public class SaveContextVisitor {
         return true;
     }
 
-    private String encodeStringToHtmlEntity(String text) {
-        if (encoding == null)
-          return text;
+    private CharSequence encodeStringToHtmlEntity(CharSequence text) {
+        if (encoding == null) return text;
+
         CharsetEncoder encoder = Charset.forName(encoding).newEncoder();
-        StringBuffer sb = new StringBuffer();
+        StringBuilder sb = new StringBuilder(text.length() + 16);
         // make sure we can handle code points that are higher than 2 bytes
-        for (int i = 0; i < text.length();) {
-            int code = text.codePointAt(i);
+        for ( int i = 0; i < text.length(); ) {
+            int code = Character.codePointAt(text, i);
             // TODO not sure about bigger offset then 2 ?!
             int offset = code > 65535 ? 2 : 1;
-            boolean canEncode = encoder.canEncode(text.substring(i, i + offset));
+            CharSequence substr = text.subSequence(i, i + offset);
+            boolean canEncode = encoder.canEncode(substr);
             if (canEncode) {
-                sb.append(text.substring(i, i + offset));
+                sb.append(substr);
             }
             else {
-                sb.append("&#x" + Integer.toHexString(code) + ";");
+                sb.append("&#x").append(Integer.toHexString(code)).append(';');
             }
             i += offset;
         }
-        return new String(sb);
+        return sb;
     }
 }

data/ext/java/nokogiri/internals/SchemaErrorHandler.java

@@ -48,9 +48,10 @@ import org.xml.sax.SAXParseException;
  * @author sergio
  * @author Yoko Harada <yokolet@gmail.com>
  */
-public class SchemaErrorHandler implements ErrorHandler{
-    private RubyArray errors;
-    private Ruby runtime;
+public class SchemaErrorHandler implements ErrorHandler {
+
+    private final Ruby runtime;
+    final RubyArray errors;
 
     public SchemaErrorHandler(Ruby ruby, RubyArray array) {
         this.runtime = ruby;
@@ -58,15 +59,11 @@ public class SchemaErrorHandler implements ErrorHandler{
     }
 
     public void warning(SAXParseException ex) throws SAXException {
-        XmlSyntaxError xmlSyntaxError = (XmlSyntaxError) NokogiriService.XML_SYNTAXERROR_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::SyntaxError"));
-        xmlSyntaxError.setException(ex);
-        this.errors.append(xmlSyntaxError);
+        errors.append( XmlSyntaxError.createWarning(runtime, ex) );
     }
 
     public void error(SAXParseException ex) throws SAXException {
-        XmlSyntaxError xmlSyntaxError = (XmlSyntaxError) NokogiriService.XML_SYNTAXERROR_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::SyntaxError"));
-        xmlSyntaxError.setException(ex);
-        this.errors.append(xmlSyntaxError);
+        errors.append( XmlSyntaxError.createError(runtime, ex) );
     }
 
     public void fatalError(SAXParseException ex) throws SAXException {

data/ext/java/nokogiri/internals/XalanDTMManagerPatch.java

@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) 2017 [Karol Bucek](http://kares.org/)
+ *
+ * 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;
+
+import org.apache.xml.dtm.DTM;
+import org.apache.xml.dtm.DTMWSFilter;
+import org.apache.xml.dtm.ref.dom2dtm.DOM2DTMExt;
+import org.apache.xml.res.XMLErrorResources;
+import org.apache.xml.res.XMLMessages;
+import org.w3c.dom.Node;
+
+import javax.xml.transform.dom.DOMSource;
+
+/**
+ * @author kares
+ */
+public final class XalanDTMManagerPatch extends org.apache.xml.dtm.ref.DTMManagerDefault {
+
+    /**
+     * Given a W3C DOM node, try and return a DTM handle.
+     * Note: calling this may be non-optimal, and there is no guarantee that
+     * the node will be found in any particular DTM.
+     *
+     * @param node Non-null reference to a DOM node.
+     *
+     * @return a valid DTM handle.
+     */
+    @Override
+    public /* synchronized */ int getDTMHandleFromNode(org.w3c.dom.Node node) {
+        //if (node == null) // "node must be non-null for getDTMHandleFromNode!");
+        //    throw new IllegalArgumentException(XMLMessages.createXMLMessage(XMLErrorResources.ER_NODE_NON_NULL, null));
+        assert node != null;
+
+        if (node instanceof org.apache.xml.dtm.ref.DTMNodeProxy) {
+            return ((org.apache.xml.dtm.ref.DTMNodeProxy) node).getDTMNodeNumber();
+        }
+
+        // Find the DOM2DTMs wrapped around this Document (if any)
+        // and check whether they contain the Node in question.
+        //
+        // NOTE that since a DOM2DTM may represent a subtree rather
+        // than a full document, we have to be prepared to check more
+        // than one -- and there is no guarantee that we will find
+        // one that contains ancestors or siblings of the node we're
+        // seeking.
+        //
+        // %REVIEW% We could search for the one which contains this
+        // node at the deepest level, and thus covers the widest
+        // subtree, but that's going to entail additional work
+        // checking more DTMs... and getHandleOfNode is not a
+        // cheap operation in most implementations.
+        //
+        // TODO: %REVIEW% If overflow addressing, we may recheck a DTM
+        // already examined. Ouch. But with the increased number of DTMs,
+        // scanning back to check this is painful.
+        // POSSIBLE SOLUTIONS:
+        //   Generate a list of _unique_ DTM objects?
+        //   Have each DTM cache last DOM node search?
+        for(int i = 0; i < m_dtms.length; i++) {
+            DTM thisDTM = m_dtms[i];
+            if (thisDTM instanceof org.apache.xml.dtm.ref.dom2dtm.DOM2DTM) {
+                int handle = ((org.apache.xml.dtm.ref.dom2dtm.DOM2DTM) thisDTM).getHandleOfNode(node);
+                if (handle != DTM.NULL) {
+                    return handle;
+                }
+            }
+        }
+
+        // Not found; generate a new DTM.
+        //
+        // %REVIEW% Is this really desirable, or should we return null
+        // and make folks explicitly instantiate from a DOMSource? The
+        // latter is more work but gives the caller the opportunity to
+        // explicitly add the DTM to a DTMManager... and thus to know when
+        // it can be discarded again, which is something we need to pay much
+        // more attention to. (Especially since only DTMs which are assigned
+        // to a manager can use the overflow addressing scheme.)
+        //
+        // %BUG% If the source node was a DOM2DTM$defaultNamespaceDeclarationNode
+        // and the DTM wasn't registered with this DTMManager, we will create
+        // a new DTM and _still_ not be able to find the node (since it will
+        // be resynthesized). Another reason to push hard on making all DTMs
+        // be managed DTMs.
+
+        // Since the real root of our tree may be a DocumentFragment, we need to
+        // use getParent to find the root, instead of getOwnerDocument.  Otherwise
+        // DOM2DTM#getHandleOfNode will be very unhappy.
+        Node root = node; int rootType = root.getNodeType();
+        Node p = (rootType == Node.ATTRIBUTE_NODE) ? ((org.w3c.dom.Attr) root).getOwnerElement() : root.getParentNode();
+        for (; p != null; p = p.getParentNode()) root = p;
+
+        // DOM2DTM dtm = (DOM2DTM) getDTM(new DOMSource(root), false, null);
+        DOM2DTMExt dtm = getDTMExt(new DOMSource(root), false, null/*, true, true*/);
+
+        int handle;
+
+        if (node instanceof org.apache.xml.dtm.ref.dom2dtm.DOM2DTMdefaultNamespaceDeclarationNode) {
+            // Can't return the same node since it's unique to a specific DTM,
+            // but can return the equivalent node -- find the corresponding
+            // Document Element, then ask it for the xml: namespace decl.
+            handle = dtm.getHandleOfNode(((org.w3c.dom.Attr) node).getOwnerElement());
+            handle = dtm.getAttributeNode(handle, node.getNamespaceURI(), node.getLocalName());
+        }
+        else {
+            handle = dtm.getHandleOfNode(node);
+
+            rootType = root.getNodeType();
+            // 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((root==node) ||
+                (rootType==Node.DOCUMENT_NODE && root==node.getOwnerDocument()) ||
+                (rootType!=Node.DOCUMENT_NODE && 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()!=Node.ATTRIBUTE_NODE)
+                            ? cursor.getParentNode()
+                            : ((org.w3c.dom.Attr)cursor).getOwnerElement()) {
+                    if (cursor==root) {
+                        // We know this node; find its handle.
+                        return (dtm).getHandleFromNode(node);
+                    }
+                } // for ancestors of node
+            } // if node and m_root in same Document
+        }
+
+        if (DTM.NULL == handle)
+            throw new RuntimeException(XMLMessages.createXMLMessage(XMLErrorResources.ER_COULD_NOT_RESOLVE_NODE, null)); //"Could not resolve the node to a handle!");
+
+        return handle;
+    }
+
+    private DOM2DTMExt getDTMExt(DOMSource source, boolean unique, DTMWSFilter whiteSpaceFilter/*, boolean incremental, boolean doIndexing*/) {
+        int dtmPos = getFirstFreeDTMID();
+        int documentID = dtmPos << IDENT_DTM_NODE_BITS;
+
+        //DOM2DTM dtm = new DOM2DTM(this, source, documentID, whiteSpaceFilter, m_xsf, true);
+        DOM2DTMExt dtm = new DOM2DTMExt(this, source, documentID, whiteSpaceFilter, m_xsf, true);
+
+        addDTM(dtm, dtmPos, 0);
+        return dtm;
+    }
+
+}