nokogiri 1.6.1-java → 1.6.2-java

data/ext/java/nokogiri/internals/NokogiriNamespaceCache.java

@@ -1,7 +1,7 @@
 /**
  * (The MIT License)
  *
- * Copyright (c) 2008 - 2012:
+ * Copyright (c) 2008 - 2014:
  *
  * * {Aaron Patterson}[http://tenderlovemaking.com]
  * * {Mike Dalessio}[http://mike.daless.io]
@@ -53,52 +53,65 @@ import org.w3c.dom.Node;
  */
 public class NokogiriNamespaceCache {
 
-    private List<Long> keys;  // order matters.
-    private Map<Integer, CacheEntry> cache;  // pair of the index of a given key and entry
+    private List<String[]> keys;
+    private Map<String[], CacheEntry> cache;  // pair of the index of a given key and entry
     private XmlNamespace defaultNamespace = null;
 
     public NokogiriNamespaceCache() {
-        keys = new ArrayList<Long>();
-        cache = new LinkedHashMap<Integer, CacheEntry>();
+        keys = new ArrayList<String[]>(); // keys are [prefix, href]
+        cache = new LinkedHashMap<String[], CacheEntry>();
     }
-    
-    private Long hashCode(String prefix, String href) {
-        long prefix_hash = prefix.hashCode();
-        long href_hash = href.hashCode();
-        return prefix_hash << 31 | href_hash;
+
+    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;
-        Long hash = hashCode(prefix, href);
-        Integer index = keys.indexOf(hash);
-        if (index != -1) return cache.get(index).namespace;
+        String[] key = getKey(prefix, href);
+        if (key != null) {
+            return cache.get(key).namespace;
+        }
         return null;
     }
-    
-    public XmlNamespace getDefault() {
-        return defaultNamespace;
-    }
-    
-    public XmlNamespace get(String prefix) {
+
+    public XmlNamespace get(Node node, String prefix) {
         if (prefix == null) return defaultNamespace;
-        long h = prefix.hashCode();
-        Long hash = h << 31;
-        Long mask = 0xFF00L;
-        for (int i=0; i < keys.size(); i++) {
-            if ((keys.get(i) & mask) == hash) {
-                return cache.get(i).namespace;
+        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<XmlNamespace> get(String prefix) {
+        List<XmlNamespace> namespaces = new ArrayList<XmlNamespace>();
+        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<XmlNamespace> get(Node node) {
         List<XmlNamespace> namespaces = new ArrayList<XmlNamespace>();
-        for (int i=0; i < keys.size(); i++) {
-            CacheEntry entry = cache.get(i);
+        for (String[] key : keys) {
+            CacheEntry entry = cache.get(key);
             if (entry.isOwner(node)) {
                 namespaces.add(entry.namespace);
             }
@@ -111,33 +124,25 @@ public class NokogiriNamespaceCache {
         // In case of a default namespace, an empty string should be given to prefix argument.
         String prefixString = namespace.getPrefix();
         String hrefString = namespace.getHref();
-        Long hash = hashCode(prefixString, hrefString);
-        Integer index;
-        if ((index = keys.indexOf(hash)) != -1) {
-            return;
-        } else {
-            keys.add(hash);
-            index = keys.size() - 1;
-            CacheEntry entry = new CacheEntry(namespace, ownerNode);
-            cache.put(index, entry);
-            if ("".equals(prefixString)) defaultNamespace = namespace;
-        }
+        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) {
-        if (prefix == null || href == null) return;
-        Long hash = hashCode(prefix, href);
-        Integer index = keys.indexOf(hash);
-        if (index != -1) {
-            cache.remove(index);
-        }
-        keys.remove(index);
+        String[] key = getKey(prefix, href);
+        if (key == null) return;
+        keys.remove(key);
+        cache.remove(key);
     }
-    
+
     public void clear() {
         // removes namespace declarations from node
-        for (int i=0; i < keys.size(); i++) {
-            CacheEntry entry = cache.get(i);
+        for (String[] key : cache.keySet()) {
+            CacheEntry entry = cache.get(key);
             NamedNodeMap attributes = entry.ownerNode.getAttributes();
             for (int j=0; j<attributes.getLength(); j++) {
                 String name = ((Attr)attributes.item(j)).getName();
@@ -150,10 +155,10 @@ public class NokogiriNamespaceCache {
         cache.clear();
         defaultNamespace = null;
     }
-    
+
     public void replaceNode(Node oldNode, Node newNode) {
-        for (int i=0; i < keys.size(); i++) {
-            CacheEntry entry = cache.get(i);
+        for (String[] key : keys) {
+            CacheEntry entry = cache.get(key);
             if (entry.isOwner(oldNode)) {
                 entry.replaceOwner(newNode);
             }
@@ -163,14 +168,14 @@ public class NokogiriNamespaceCache {
     private class CacheEntry {
         private XmlNamespace namespace;
         private Node ownerNode;
-        
+
         CacheEntry(XmlNamespace namespace, Node ownerNode) {
             this.namespace = namespace;
             this.ownerNode = ownerNode;
         }
 
         public Boolean isOwner(Node n) {
-            return this.ownerNode.isSameNode(n);
+            return ownerNode.isSameNode(n);
         }
 
         public void replaceOwner(Node newNode) {

data/ext/java/nokogiri/internals/NokogiriXPathFunctionResolver.java

@@ -63,7 +63,7 @@ public class NokogiriXPathFunctionResolver implements XPathFunctionResolver {
     
     private NokogiriXPathFunctionResolver() {}
     
-    private void setHandler(IRubyObject handler) {
+    public void setHandler(IRubyObject handler) {
         this.handler = handler;
     }
 

data/ext/java/nokogiri/internals/ParserContext.java

@@ -33,7 +33,7 @@
 package nokogiri.internals;
 
 import static nokogiri.internals.NokogiriHelpers.rubyStringToString;
-import static org.jruby.javasupport.util.RuntimeHelpers.invoke;
+import static org.jruby.runtime.Helpers.invoke;
 
 import java.io.ByteArrayInputStream;
 import java.io.File;
@@ -46,12 +46,9 @@ import java.nio.charset.UnsupportedCharsetException;
 
 import org.jruby.Ruby;
 import org.jruby.RubyClass;
-import org.jruby.RubyFixnum;
 import org.jruby.RubyIO;
 import org.jruby.RubyObject;
 import org.jruby.RubyString;
-import org.jruby.RubyStringIO;
-import org.jruby.exceptions.RaiseException;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.util.ByteList;

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

@@ -439,9 +439,13 @@ public class SaveContextVisitor {
             buffer.append(">");
         } else if (asXml && noEmpty) {
             buffer.append(">");
+        } else if (asXhtml) {
+            if (isEmpty(name)) {
+                buffer.append(" />"); // see http://www.w3.org/TR/xhtml1/#C_2
+            } else {
+                buffer.append(">");
+            }
         } else {
-            if (asXhtml)
-              buffer.append(" "); // see http://www.w3.org/TR/xhtml1/#C_2
             buffer.append("/>");
         }
         if (needBreakInOpening(element)) {

data/ext/java/nokogiri/internals/c14n/AttrCompare.java

@@ -0,0 +1,119 @@
+/**
+ * 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.c14n;
+
+import java.io.Serializable;
+import java.util.Comparator;
+
+
+import org.w3c.dom.Attr;
+
+/**
+ * Compares two attributes based on the C14n specification.
+ *
+ * <UL>
+ * <LI>Namespace nodes have a lesser document order position than attribute 
+ *   nodes.
+ * <LI> An element's namespace nodes are sorted lexicographically by
+ *   local name (the default namespace node, if one exists, has no
+ *   local name and is therefore lexicographically least).
+ * <LI> An element's attribute nodes are sorted lexicographically with
+ *   namespace URI as the primary key and local name as the secondary
+ *   key (an empty namespace URI is lexicographically least).
+ * </UL>
+ *
+ * @author Christian Geuer-Pollmann
+ */
+public class AttrCompare implements Comparator<Attr>, Serializable {
+
+    private static final long serialVersionUID = -7113259629930576230L;
+    private static final int ATTR0_BEFORE_ATTR1 = -1;
+    private static final int ATTR1_BEFORE_ATTR0 = 1;
+    private static final String XMLNS = Constants.NamespaceSpecNS;
+
+    /**
+     * Compares two attributes based on the C14n specification.
+     *
+     * <UL>
+     * <LI>Namespace nodes have a lesser document order position than 
+     *   attribute nodes.
+     * <LI> An element's namespace nodes are sorted lexicographically by
+     *   local name (the default namespace node, if one exists, has no
+     *   local name and is therefore lexicographically least).
+     * <LI> An element's attribute nodes are sorted lexicographically with
+     *   namespace URI as the primary key and local name as the secondary
+     *   key (an empty namespace URI is lexicographically least).
+     * </UL>
+     *
+     * @param attr0
+     * @param attr1
+     * @return returns a negative integer, zero, or a positive integer as 
+     *   obj0 is less than, equal to, or greater than obj1
+     *
+     */
+    public int compare(Attr attr0, Attr attr1) {
+        String namespaceURI0 = attr0.getNamespaceURI();      
+        String namespaceURI1 = attr1.getNamespaceURI();
+      
+        boolean isNamespaceAttr0 = XMLNS.equals(namespaceURI0);
+        boolean isNamespaceAttr1 = XMLNS.equals(namespaceURI1);
+
+        if (isNamespaceAttr0) {
+            if (isNamespaceAttr1) {
+                // both are namespaces
+                String localname0 = attr0.getLocalName();
+                String localname1 = attr1.getLocalName();
+
+                if ("xmlns".equals(localname0)) {
+                    localname0 = "";
+                }
+
+                if ("xmlns".equals(localname1)) {
+                    localname1 = "";
+                }
+
+                return localname0.compareTo(localname1);
+            }
+            // attr0 is a namespace, attr1 is not
+            return ATTR0_BEFORE_ATTR1;
+        } else if (isNamespaceAttr1) {
+            // attr1 is a namespace, attr0 is not
+            return ATTR1_BEFORE_ATTR0;
+        } 
+
+        // none is a namespace
+        if (namespaceURI0 == null) {
+            if (namespaceURI1 == null) {
+                String name0 = attr0.getName();
+                String name1 = attr1.getName();
+                return name0.compareTo(name1);
+            }
+            return ATTR0_BEFORE_ATTR1;
+        } else if (namespaceURI1 == null) {
+            return ATTR1_BEFORE_ATTR0;
+        } 
+
+        int a = namespaceURI0.compareTo(namespaceURI1);
+        if (a != 0) {
+            return a;
+        }
+      
+        return (attr0.getLocalName()).compareTo(attr1.getLocalName());
+    }
+}

data/ext/java/nokogiri/internals/c14n/C14nHelper.java

@@ -0,0 +1,159 @@
+/**
+ * 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.c14n;
+
+
+import org.w3c.dom.Attr;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.NamedNodeMap;
+
+/**
+ * Temporary swapped static functions from the normalizer Section
+ *
+ * @author Christian Geuer-Pollmann
+ */
+public class C14nHelper {
+
+    /**
+     * Constructor C14nHelper
+     *
+     */
+    private C14nHelper() {
+        // don't allow instantiation
+    }
+
+    /**
+     * Method namespaceIsRelative
+     *
+     * @param namespace
+     * @return true if the given namespace is relative. 
+     */
+    public static boolean namespaceIsRelative(Attr namespace) {
+        return !namespaceIsAbsolute(namespace);
+    }
+
+    /**
+     * Method namespaceIsRelative
+     *
+     * @param namespaceValue
+     * @return true if the given namespace is relative.
+     */
+    public static boolean namespaceIsRelative(String namespaceValue) {
+        return !namespaceIsAbsolute(namespaceValue);
+    }
+
+    /**
+     * Method namespaceIsAbsolute
+     *
+     * @param namespace
+     * @return true if the given namespace is absolute.
+     */
+    public static boolean namespaceIsAbsolute(Attr namespace) {
+        return namespaceIsAbsolute(namespace.getValue());
+    }
+
+    /**
+     * Method namespaceIsAbsolute
+     *
+     * @param namespaceValue
+     * @return true if the given namespace is absolute.
+     */
+    public static boolean namespaceIsAbsolute(String namespaceValue) {
+        // assume empty namespaces are absolute
+        if (namespaceValue.length() == 0) {
+            return true;
+        }
+        return namespaceValue.indexOf(':') > 0;
+    }
+
+    /**
+     * This method throws an exception if the Attribute value contains
+     * a relative URI.
+     *
+     * @param attr
+     * @throws CanonicalizationException
+     */
+    public static void assertNotRelativeNS(Attr attr) throws CanonicalizationException {
+        if (attr == null) {
+            return;
+        }
+
+        String nodeAttrName = attr.getNodeName();
+        boolean definesDefaultNS = nodeAttrName.equals("xmlns");
+        boolean definesNonDefaultNS = nodeAttrName.startsWith("xmlns:");
+
+        if ((definesDefaultNS || definesNonDefaultNS) && namespaceIsRelative(attr)) {
+            String parentName = attr.getOwnerElement().getTagName();
+            String attrValue = attr.getValue();
+            Object exArgs[] = { parentName, nodeAttrName, attrValue };
+
+            throw new CanonicalizationException(
+                "c14n.Canonicalizer.RelativeNamespace", exArgs
+            );
+        }
+    }
+
+    /**
+     * This method throws a CanonicalizationException if the supplied Document
+     * is not able to be traversed using a TreeWalker.
+     *
+     * @param document
+     * @throws CanonicalizationException
+     */
+    public static void checkTraversability(Document document)
+        throws CanonicalizationException {
+        if (!document.isSupported("Traversal", "2.0")) {
+            Object exArgs[] = {document.getImplementation().getClass().getName() };
+
+            throw new CanonicalizationException(
+                "c14n.Canonicalizer.TraversalNotSupported", exArgs
+            );
+        }
+    }
+
+    /**
+     * This method throws a CanonicalizationException if the supplied Element
+     * contains any relative namespaces.
+     *
+     * @param ctxNode
+     * @throws CanonicalizationException
+     * @see C14nHelper#assertNotRelativeNS(Attr)
+     */
+    public static void checkForRelativeNamespace(Element ctxNode)
+        throws CanonicalizationException {
+        if (ctxNode != null) {
+            NamedNodeMap attributes = ctxNode.getAttributes();
+
+            for (int i = 0; i < attributes.getLength(); i++) {
+                C14nHelper.assertNotRelativeNS((Attr) attributes.item(i));
+            }
+        } else {
+            throw new CanonicalizationException("Called checkForRelativeNamespace() on null");
+        }
+    }
+    
+    public static String getErrorMessage(String message, Object... exArgs) {
+        StringBuffer sb = new StringBuffer(message);
+        for (Object arg : exArgs) {
+            sb.append(", ").append(arg.toString());
+        }
+        return new String(sb);
+    }
+}