nokogiri 1.10.10-java → 1.11.0.rc1-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/NokogiriXPathFunction.java

@@ -53,6 +53,8 @@ import org.w3c.dom.NodeList;
 import nokogiri.XmlNode;
 import nokogiri.XmlNodeSet;
 
+import static nokogiri.internals.NokogiriHelpers.nodeListToRubyArray;
+
 /**
  * Xpath function handler.
  * 
@@ -99,9 +101,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,7 +117,7 @@ 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();
     }

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);
     }

data/ext/java/nokogiri/internals/ReaderNode.java

@@ -113,15 +113,13 @@ public abstract class ReaderNode {
         RubyArray array = RubyArray.newArray(ruby);
         if (attributeList != null && attributeList.length > 0) {
             if (document == null) {
-                XmlDocument doc = (XmlDocument) XmlDocument.rbNew(ruby.getCurrentContext(), getNokogiriClass(ruby, "Nokogiri::XML::Document"), new IRubyObject[0]);
-                document = doc.getDocument();
+                document = XmlDocument.createNewDocument(ruby);
             }
             for (int i=0; i<attributeList.length; i++) {
                 if (!isNamespace(attributeList.names.get(i))) {
                     Attr attr = document.createAttributeNS(attributeList.namespaces.get(i), attributeList.names.get(i));
                     attr.setValue(attributeList.values.get(i));
-                    XmlAttr xmlAttr = (XmlAttr) NokogiriService.XML_ATTR_ALLOCATOR.allocate(ruby, getNokogiriClass(ruby, "Nokogiri::XML::Attr"));
-                    xmlAttr.setNode(ruby.getCurrentContext(), attr);
+                    XmlAttr xmlAttr = new XmlAttr(ruby, attr);
                     array.append(xmlAttr);
                 }
             }

data/ext/java/nokogiri/internals/XmlDomParserContext.java

@@ -39,11 +39,6 @@ import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 
-import nokogiri.NokogiriService;
-import nokogiri.XmlDocument;
-import nokogiri.XmlDtd;
-import nokogiri.XmlSyntaxError;
-
 import org.apache.xerces.parsers.DOMParser;
 import org.jruby.Ruby;
 import org.jruby.RubyArray;
@@ -57,6 +52,11 @@ import org.w3c.dom.Node;
 import org.w3c.dom.NodeList;
 import org.xml.sax.SAXException;
 
+import nokogiri.NokogiriService;
+import nokogiri.XmlDocument;
+import nokogiri.XmlDtd;
+import nokogiri.XmlSyntaxError;
+
 /**
  * Parser class for XML DOM processing. This class actually parses XML document
  * and creates DOM tree in Java side. However, DOM tree in Ruby side is not since
@@ -84,7 +84,6 @@ public class XmlDomParserContext extends ParserContext {
     protected ParserContext.Options options;
     protected DOMParser parser;
     protected NokogiriErrorHandler errorHandler;
-    protected String java_encoding;
     protected IRubyObject ruby_encoding;
 
     public XmlDomParserContext(Ruby runtime, IRubyObject options) {
@@ -94,7 +93,7 @@ public class XmlDomParserContext extends ParserContext {
     public XmlDomParserContext(Ruby runtime, IRubyObject encoding, IRubyObject options) {
         super(runtime);
         this.options = new ParserContext.Options(RubyFixnum.fix2long(options));
-        java_encoding = NokogiriHelpers.getValidEncoding(runtime, encoding);
+        java_encoding = NokogiriHelpers.getValidEncoding(encoding);
         ruby_encoding = encoding;
         initErrorHandler();
         initParser(runtime);
@@ -201,37 +200,25 @@ public class XmlDomParserContext extends ParserContext {
         }
     }
     
-    private XmlDocument getInterruptedOrNewXmlDocument(ThreadContext context, RubyClass klazz) {
+    private XmlDocument getInterruptedOrNewXmlDocument(ThreadContext context, RubyClass klass) {
         Document document = parser.getDocument();
-        XmlDocument xmlDocument = (XmlDocument) NokogiriService.XML_DOCUMENT_ALLOCATOR.allocate(context.getRuntime(), klazz);
-        if (document != null) {
-            xmlDocument.setDocumentNode(context, document);
-        }
+        XmlDocument xmlDocument = new XmlDocument(context.runtime, klass, document);
         xmlDocument.setEncoding(ruby_encoding);
         return xmlDocument;
     }
 
-    protected XmlDocument getNewEmptyDocument(ThreadContext context) {
-        IRubyObject[] args = new IRubyObject[0];
-        return (XmlDocument) XmlDocument.rbNew(context, getNokogiriClass(context.getRuntime(), "Nokogiri::XML::Document"), args);
-    }
-
     /**
      * This method is broken out so that HtmlDomParserContext can
      * override it.
      */
-    protected XmlDocument wrapDocument(ThreadContext context,
-                                       RubyClass klazz,
-                                       Document doc) {
-        XmlDocument xmlDocument = (XmlDocument) NokogiriService.XML_DOCUMENT_ALLOCATOR.allocate(context.getRuntime(), klazz);
-        xmlDocument.setDocumentNode(context, doc);
+    protected XmlDocument wrapDocument(ThreadContext context, RubyClass klass, Document doc) {
+        XmlDocument xmlDocument = new XmlDocument(context.runtime, klass, doc);
         xmlDocument.setEncoding(ruby_encoding);
 
         if (options.dtdLoad) {
-            IRubyObject xmlDtdOrNil = XmlDtd.newFromExternalSubset(context.getRuntime(), doc);
-            if (!xmlDtdOrNil.isNil()) {
-                XmlDtd xmlDtd = (XmlDtd) xmlDtdOrNil;
-                doc.setUserData(XmlDocument.DTD_EXTERNAL_SUBSET, xmlDtd, null);
+            IRubyObject dtd = XmlDtd.newFromExternalSubset(context.runtime, doc);
+            if (!dtd.isNil()) {
+                doc.setUserData(XmlDocument.DTD_EXTERNAL_SUBSET, (XmlDtd) dtd, null);
             }
         }
         return xmlDocument;
@@ -240,20 +227,18 @@ public class XmlDomParserContext extends ParserContext {
     /**
      * Must call setInputSource() before this method.
      */
-    public XmlDocument parse(ThreadContext context,
-                             IRubyObject klazz,
-                             IRubyObject url) {
+    public XmlDocument parse(ThreadContext context, RubyClass klass, IRubyObject url) {
         XmlDocument xmlDoc;
         try {
             Document doc = do_parse();
-            xmlDoc = wrapDocument(context, (RubyClass)klazz, doc);
+            xmlDoc = wrapDocument(context, klass, doc);
             xmlDoc.setUrl(url);
             addErrorsIfNecessary(context, xmlDoc);
             return xmlDoc;
         } catch (SAXException e) {
-            return getDocumentWithErrorsOrRaiseException(context, (RubyClass)klazz, e);
+            return getDocumentWithErrorsOrRaiseException(context, klass, e);
         } catch (IOException e) {
-            return getDocumentWithErrorsOrRaiseException(context, (RubyClass)klazz, e);
+            return getDocumentWithErrorsOrRaiseException(context, klass, e);
         }
     }