nokogiri 1.10.10-java → 1.11.0-java

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

@@ -46,49 +46,43 @@ import org.w3c.dom.NamedNodeMap;
 import org.w3c.dom.Node;
 
 /**
- * Cache of namespages of each node. XmlDocument has one cache of this class.
+ * Cache of namespaces of each node. XmlDocument has one cache of this class.
  * 
  * @author sergio
  * @author Yoko Harada <yokolet@gmail.com>
  */
 public class NokogiriNamespaceCache {
 
-    private List<String[]> keys;
-    private Map<String[], CacheEntry> cache;  // pair of the index of a given key and entry
+    private final Map<CacheKey, CacheEntry> cache;  // pair of the index of a given key and entry
     private XmlNamespace defaultNamespace = null;
 
     public NokogiriNamespaceCache() {
-        keys = new ArrayList<String[]>(); // keys are [prefix, href]
-        cache = new LinkedHashMap<String[], CacheEntry>();
+        this.cache = new LinkedHashMap<CacheKey, CacheEntry>(4);
     }
 
-    public XmlNamespace getDefault() {
-        return defaultNamespace;
+    public NokogiriNamespaceCache(NokogiriNamespaceCache cache) {
+        this.cache = new LinkedHashMap<CacheKey, CacheEntry>(cache.size() + 2);
+        this.cache.putAll(cache.cache);
     }
 
-    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 getDefault() {
+        return defaultNamespace;
     }
 
     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;
+        if (href == null) return null;
+
+        CacheEntry value = cache.get(new CacheKey(prefix, href));
+        return value == null ? null : value.namespace;
     }
 
     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;
+        for (Map.Entry<CacheKey, CacheEntry> entry : cache.entrySet()) {
+            if (entry.getKey().prefix.equals(prefix)) {
+                if (entry.getValue().isOwner(node)) {
+                    return entry.getValue().namespace;
+                }
             }
         }
         return null;
@@ -100,9 +94,9 @@ public class NokogiriNamespaceCache {
             namespaces.add(defaultNamespace);
             return namespaces;
         }
-        for (String[] key : keys) {
-            if (key[0].equals(prefix) && cache.get(key) != null) {
-                namespaces.add(cache.get(key).namespace);
+        for (Map.Entry<CacheKey, CacheEntry> entry : cache.entrySet()) {
+            if (entry.getKey().prefix.equals(prefix)) {
+                namespaces.add(entry.getValue().namespace);
             }
         }
         return namespaces;
@@ -110,63 +104,96 @@ public class NokogiriNamespaceCache {
 
     public List<XmlNamespace> get(Node node) {
         List<XmlNamespace> namespaces = new ArrayList<XmlNamespace>();
-        for (String[] key : keys) {
-            CacheEntry entry = cache.get(key);
-            if (entry.isOwner(node)) {
-                namespaces.add(entry.namespace);
+        for (Map.Entry<CacheKey, CacheEntry> entry : cache.entrySet()) {
+            if (entry.getValue().isOwner(node)) {
+                namespaces.add(entry.getValue().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;
+        String prefix = namespace.getPrefix();
+        String href = namespace.getHref();
+        if (href == null) return;
+
+        CacheKey key = new CacheKey(prefix, href);
+        if (cache.get(key) != null) return;
+        cache.put(key, new CacheEntry(namespace, ownerNode));
+        if ("".equals(prefix)) 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 remove(Node ownerNode) {
+        String prefix = ownerNode.getPrefix();
+        String href = ownerNode.getNamespaceURI();
+        if (href == null) return;
+
+        cache.remove(new CacheKey(prefix, href));
+    }
+
+    public int size() {
+        return cache.size();
     }
 
     public void clear() {
         // removes namespace declarations from node
-        for (String[] key : cache.keySet()) {
-            CacheEntry entry = cache.get(key);
+        for (CacheEntry entry : cache.values()) {
             NamedNodeMap attributes = entry.ownerNode.getAttributes();
             for (int j=0; j<attributes.getLength(); j++) {
-                String name = ((Attr)attributes.item(j)).getName();
+                String name = ((Attr) attributes.item(j)).getName();
                 if (isNamespace(name)) {
                     attributes.removeNamedItem(name);
                 }
             }
         }
-        keys.clear();
         cache.clear();
         defaultNamespace = null;
     }
 
     public void replaceNode(Node oldNode, Node newNode) {
-        for (String[] key : keys) {
-            CacheEntry entry = cache.get(key);
-            if (entry.isOwner(oldNode)) {
-                entry.replaceOwner(newNode);
+        for (Map.Entry<CacheKey, CacheEntry> entry : cache.entrySet()) {
+            if (entry.getValue().isOwner(oldNode)) {
+                entry.getValue().replaceOwner(newNode);
+            }
+        }
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getName() + '@' + Integer.toHexString(hashCode()) + '(' + cache + "default=" + defaultNamespace + ')';
+    }
+
+    private static class CacheKey {
+        final String prefix;
+        final String href;
+
+        CacheKey(String prefix, String href) {
+            this.prefix = prefix;
+            this.href = href;
+        }
+
+        @Override
+        public boolean equals(final Object obj) {
+            if (obj instanceof CacheKey) {
+                CacheKey that = (CacheKey) obj;
+                return prefix == null ? that.prefix == null : prefix.equals(that.prefix) && href.equals(that.href);
             }
+            return false;
+        }
+
+        @Override
+        public int hashCode() {
+            return (prefix == null ? 0 : prefix.hashCode()) + 37 * href.hashCode();
+        }
+
+        @Override
+        public String toString() {
+            return '[' + prefix + ']' + href;
         }
     }
 
-    private class CacheEntry {
-        private XmlNamespace namespace;
+    private static class CacheEntry {
+        final XmlNamespace namespace;
         private Node ownerNode;
 
         CacheEntry(XmlNamespace namespace, Node ownerNode) {
@@ -174,12 +201,17 @@ public class NokogiriNamespaceCache {
             this.ownerNode = ownerNode;
         }
 
-        public Boolean isOwner(Node n) {
-            return ownerNode.isSameNode(n);
+        boolean isOwner(Node node) {
+            return ownerNode.isSameNode(node);
         }
 
-        public void replaceOwner(Node newNode) {
+        void replaceOwner(Node newNode) {
             this.ownerNode = newNode;
         }
+
+        @Override
+        public String toString() {
+            return namespace.toString();
+        }
     }
 }

data/ext/java/nokogiri/internals/NokogiriNamespaceContext.java

@@ -50,9 +50,15 @@ import javax.xml.namespace.NamespaceContext;
  */
 public final class NokogiriNamespaceContext implements NamespaceContext {
 
-	public static final String NOKOGIRI_PREFIX = "nokogiri";
+    /*
+     * these constants have matching declarations in
+     * ext/nokogiri/xml_xpath_context.c
+     */
+    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";
+
+    public static final String NOKOGIRI_BUILTIN_PREFIX = "nokogiri-builtin";
+    public static final String NOKOGIRI_BUILTIN_URI = "https://www.nokogiri.org/default_ns/ruby/builtins";
     
     private final Map<String,String> register;
 
@@ -63,6 +69,7 @@ public final class NokogiriNamespaceContext implements NamespaceContext {
     private NokogiriNamespaceContext() {
         register = new HashMap<String, String>(6, 1);
         register.put(NOKOGIRI_PREFIX, NOKOGIRI_URI);
+        register.put(NOKOGIRI_BUILTIN_PREFIX, NOKOGIRI_BUILTIN_URI);
         register.put("xml", "http://www.w3.org/XML/1998/namespace");
         register.put("xhtml", "http://www.w3.org/1999/xhtml");
     }

data/ext/java/nokogiri/internals/NokogiriXPathFunction.java

@@ -36,6 +36,7 @@ import java.util.List;
 
 import javax.xml.xpath.XPathFunction;
 import javax.xml.xpath.XPathFunctionException;
+import javax.xml.namespace.QName;
 
 import org.jruby.Ruby;
 import org.jruby.RubyArray;
@@ -53,6 +54,8 @@ import org.w3c.dom.NodeList;
 import nokogiri.XmlNode;
 import nokogiri.XmlNodeSet;
 
+import static nokogiri.internals.NokogiriHelpers.nodeListToRubyArray;
+
 /**
  * Xpath function handler.
  * 
@@ -62,14 +65,14 @@ import nokogiri.XmlNodeSet;
 public class NokogiriXPathFunction implements XPathFunction {
 
     private final IRubyObject handler;
-    private final String name;
+    private final QName name;
     private final int arity;
     
-    public static NokogiriXPathFunction create(IRubyObject handler, String name, int arity) {
+    public static NokogiriXPathFunction create(IRubyObject handler, QName name, int arity) {
         return new NokogiriXPathFunction(handler, name, arity);
     }
 
-    private NokogiriXPathFunction(IRubyObject handler, String name, int arity) {
+    private NokogiriXPathFunction(IRubyObject handler, QName name, int arity) {
         this.handler = handler;
         this.name = name;
         this.arity = arity;
@@ -80,11 +83,20 @@ public class NokogiriXPathFunction implements XPathFunction {
             throw new XPathFunctionException("arity does not match");
         }
         
-        final Ruby runtime = this.handler.getRuntime();
-        ThreadContext context = runtime.getCurrentContext();
+        if (name.getNamespaceURI().equals(NokogiriNamespaceContext.NOKOGIRI_BUILTIN_URI)) {
+            if (name.getLocalPart().equals("css-class")) {
+                return builtinCssClass(args);
+            }
+        }
 
-        IRubyObject result = Helpers.invoke(context, this.handler, this.name, fromObjectToRubyArgs(runtime, args));
+        if (this.handler.isNil()) {
+            throw new XPathFunctionException("no custom function handler declared for '" + name + "'");
+        }
 
+        final Ruby runtime = this.handler.getRuntime();
+        ThreadContext context = runtime.getCurrentContext();
+        IRubyObject result = Helpers.invoke(context, this.handler, this.name.getLocalPart(),
+                                            fromObjectToRubyArgs(runtime, args));
         return fromRubyToObject(runtime, result);
     }
 
@@ -99,9 +111,8 @@ public class NokogiriXPathFunction implements XPathFunction {
     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;
+            IRubyObject[] nodes = nodeListToRubyArray(runtime, (NodeList) obj);
+            return XmlNodeSet.newNodeSet(runtime, nodes);
         }
         return JavaUtil.convertJavaToUsableRubyObject(runtime, obj);
     }
@@ -116,8 +127,54 @@ public class NokogiriXPathFunction implements XPathFunction {
         }
         if (obj instanceof XmlNodeSet) return obj;
         if (obj instanceof RubyArray) {
-            return XmlNodeSet.newXmlNodeSet(runtime.getCurrentContext(), ((RubyArray) obj).toJavaArray());
+            return XmlNodeSet.newNodeSet(runtime, ((RubyArray) obj).toJavaArray());
         }
         /*if (o instanceof XmlNode)*/ return ((XmlNode) obj).getNode();
     }
+
+    private static boolean builtinCssClass(List args) throws XPathFunctionException {
+        if (args.size() != 2) {
+            throw new XPathFunctionException("builtin function nokogiri:css-class takes two arguments");
+        }
+
+        String hay = args.get(0).toString();
+        String needle = args.get(1).toString();
+
+        if (needle.length() == 0) {
+            return true;
+        }
+
+        int j = 0;
+        int j_lim = hay.length() - needle.length();
+        while (j <= j_lim) {
+            int k;
+            for (k = 0; k < needle.length(); k++) {
+                if (needle.charAt(k) != hay.charAt(j+k)) {
+                    break;
+                }
+            }
+            if (k == needle.length()) {
+                if ((hay.length() == (j+k)) || isWhitespace(hay.charAt(j+k))) {
+                    return true ;
+                }
+            }
+
+            /* advance str to whitespace */
+            while (j <= j_lim && !isWhitespace(hay.charAt(j))) {
+                j++;
+            }
+
+            /* advance str to start of next word or end of string */
+            while (j <= j_lim && isWhitespace(hay.charAt(j))) {
+                j++;
+            }
+        }
+
+        return false;
+    }
+
+    private static boolean isWhitespace(char subject) {
+        // see libxml2's xmlIsBlank_ch()
+        return ((subject == 0x09) || (subject == 0x0A) || (subject == 0x0D) || (subject == 0x20));
+    }
 }

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

@@ -50,7 +50,9 @@ public final class NokogiriXPathFunctionResolver implements XPathFunctionResolve
     
     public static NokogiriXPathFunctionResolver create(IRubyObject handler) {
         NokogiriXPathFunctionResolver freshResolver = new NokogiriXPathFunctionResolver();
-        freshResolver.setHandler(handler);
+        if (!handler.isNil()) {
+            freshResolver.setHandler(handler);
+        }
         return freshResolver;
     }
     
@@ -65,6 +67,6 @@ public final class NokogiriXPathFunctionResolver implements XPathFunctionResolve
     }
 
     public XPathFunction resolveFunction(QName name, int arity) {
-        return NokogiriXPathFunction.create(handler, name.getLocalPart(), arity);
+        return NokogiriXPathFunction.create(handler, name, arity);
     }
 }

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

@@ -33,27 +33,22 @@
 package nokogiri.internals;
 
 import static nokogiri.internals.NokogiriHelpers.rubyStringToString;
-import static org.jruby.runtime.Helpers.invoke;
 
 import java.io.ByteArrayInputStream;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
-import java.io.StringReader;
 import java.net.URI;
-import java.nio.charset.Charset;
-import java.nio.charset.UnsupportedCharsetException;
 import java.util.concurrent.Callable;
 
 import org.jruby.Ruby;
 import org.jruby.RubyClass;
-import org.jruby.RubyIO;
 import org.jruby.RubyObject;
 import org.jruby.RubyString;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.util.ByteList;
-import org.jruby.util.TypeConverter;
+import org.jruby.util.IOInputStream;
 import org.xml.sax.InputSource;
 
 /**
@@ -67,6 +62,7 @@ public abstract class ParserContext extends RubyObject {
     protected InputSource source = null;
     protected IRubyObject detected_encoding = null;
     protected int stringDataSize = -1;
+    protected String java_encoding;
 
     public ParserContext(Ruby runtime) {
         // default to class 'Object' because this class isn't exposed to Ruby
@@ -81,68 +77,42 @@ public abstract class ParserContext extends RubyObject {
         return source;
     }
 
-    /**
-     * Set the InputSource from <code>url</code> or <code>data</code>,
-     * which may be an IO object, a String, or a StringIO.
-     */
-    public void setInputSource(ThreadContext context, IRubyObject data, IRubyObject url) {
+    public void setIOInputSource(ThreadContext context, IRubyObject data, IRubyObject url) {
         source = new InputSource();
-
-        Ruby ruby = context.getRuntime();
-
         ParserContext.setUrl(context, source, url);
 
-        // if setEncoding returned true, then the stream is set
-        // to the EncodingReaderInputStream
-        if (setEncoding(context, data))
-          return;
-
-        RubyString stringData = null;
-        if (invoke(context, data, "respond_to?", ruby.newSymbol("to_io")).isTrue()) {
-            RubyIO io =
-                (RubyIO) TypeConverter.convertToType(data,
-                                                     ruby.getIO(),
-                                                     "to_io");
-            // use unclosedable input stream to fix #495
-            source.setByteStream(new UncloseableInputStream(io.getInStream()));
-
-        } else if (invoke(context, data, "respond_to?", ruby.newSymbol("read")).isTrue()) {
-            stringData = invoke(context, data, "read").convertToString();
+        source.setByteStream(new IOInputStream(data));
+        if (java_encoding != null) {
+            source.setEncoding(java_encoding);
+        }
+    }
 
-        } else if (invoke(context, data, "respond_to?", ruby.newSymbol("string")).isTrue()) {
-            stringData = invoke(context, data, "string").convertToString();
+    public void setStringInputSource(ThreadContext context, IRubyObject data, IRubyObject url) {
+        source = new InputSource();
+        ParserContext.setUrl(context, source, url);
 
-        } else if (data instanceof RubyString) {
-            stringData = (RubyString) data;
+        Ruby ruby = context.getRuntime();
 
-        } else {
-            throw ruby.newArgumentError("must be kind_of String or respond to :to_io, :read, or :string");
+        if (!(data instanceof RubyString)) {
+            throw ruby.newArgumentError("must be kind_of String");
         }
 
-        if (stringData != null) {
-            String encName = null;
-            if (stringData.encoding(context) != null) {
-                encName = stringData.encoding(context).toString();
-            }
-            Charset charset = null;
+        RubyString stringData = (RubyString) data;
+
+        if (stringData.encoding(context) != null) {
+            RubyString stringEncoding = stringData.encoding(context).asString();
+            String encName = NokogiriHelpers.getValidEncodingOrNull(stringEncoding);
             if (encName != null) {
-                try {
-                    charset = Charset.forName(encName);
-                } catch (UnsupportedCharsetException e) {
-                    // do nothing;
-                }
-            }
-            ByteList bytes = stringData.getByteList();
-            if (charset != null) {
-                StringReader reader = new StringReader(new String(bytes.unsafeBytes(), bytes.begin(), bytes.length(), charset));
-                source.setCharacterStream(reader);
-                source.setEncoding(charset.name());
-            } else {
-                stringDataSize = bytes.length() - bytes.begin();
-                ByteArrayInputStream stream = new ByteArrayInputStream(bytes.unsafeBytes(), bytes.begin(), bytes.length());
-                source.setByteStream(stream);
+                java_encoding = encName;
             }
         }
+
+        ByteList bytes = stringData.getByteList();
+
+        stringDataSize = bytes.length() - bytes.begin();
+        ByteArrayInputStream stream = new ByteArrayInputStream(bytes.unsafeBytes(), bytes.begin(), bytes.length());
+        source.setByteStream(stream);
+        source.setEncoding(java_encoding);
     }
 
     public static void setUrl(ThreadContext context, InputSource source, IRubyObject url) {
@@ -171,22 +141,6 @@ public abstract class ParserContext extends RubyObject {
         }
     }
 
-    private boolean setEncoding(ThreadContext context, IRubyObject data) {
-        if (data.getType().respondsTo("detect_encoding")) {
-            // in case of EncodingReader is used
-            // since EncodingReader won't respond to :to_io
-            NokogiriEncodingReaderWrapper reader = new NokogiriEncodingReaderWrapper(context, (RubyObject) data);
-            source.setByteStream(reader);
-            // data is EnocodingReader
-            if(reader.detectEncoding()) {
-              detected_encoding = reader.getEncoding();
-              source.setEncoding(detected_encoding.asJavaString());
-            }
-            return true;
-        }
-        return false;
-    }
-    
     protected void setEncoding(String encoding) {
     	source.setEncoding(encoding);
     }