nokogiri 1.8.5-java → 1.9.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: e9727f93d46220b9a004551304a4ec6cba2243ac
-  data.tar.gz: 41168fc5b0521a0d28c06790cfc9c33b4ec0d37c
+SHA256:
+  metadata.gz: 91e6ae003618927051f0376df1b2ebf3eece79ac535a15e874c95ec0850e3bd0
+  data.tar.gz: 2f1f1f47c821664706826c4eb46120ef08e8d7f88561ccc43fbf95df463865c7
 SHA512:
-  metadata.gz: 737c5fa0fff34cb9f8976f57c0b5b5dfe465b288b420f60af77159ca95c4b7d7dce7c990f1ef692fc0eccf94bcfed468ea483a377ca5784858fbfa3893585f0b
-  data.tar.gz: 88d8fbfe169eff929bc5fca87a5316c5d2a42f56bf07263e8a63e48a893ee4edd3c3292f144f36044ac53d321338dbd668912ded2077d962e0637d4c43936b01
+  metadata.gz: de19599baccd1ef2be9b9db9076996dd6c301e6467891ba06433a55adbc2aec03a377b100178acce4093e5b950533eba7e6298e55f11346edc817093b7fc4947
+  data.tar.gz: da62dac978f94e9cfab0515090cb1c34c27c1bee796efe4d8a010eacb91bcf30536e9edc49412b4d776e61a390801fcc4c5d5ea81b8e001fd2824718a8af5d9a

data/README.md

@@ -18,7 +18,6 @@ or CSS3 selectors.
 
 [![Concourse CI](https://ci.nokogiri.org/api/v1/teams/nokogiri-core/pipelines/nokogiri/jobs/ruby-2.4-system/badge)](https://ci.nokogiri.org/teams/nokogiri-core/pipelines/nokogiri?groups=master)
 [![Code Climate](https://codeclimate.com/github/sparklemotion/nokogiri.svg)](https://codeclimate.com/github/sparklemotion/nokogiri)
-[![Version Eye](https://www.versioneye.com/ruby/nokogiri/badge.png)](https://www.versioneye.com/ruby/nokogiri)
 [![Join the chat at https://gitter.im/sparklemotion/nokogiri](https://badges.gitter.im/sparklemotion/nokogiri.svg)](https://gitter.im/sparklemotion/nokogiri?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 

data/ext/java/nokogiri/XmlAttr.java

@@ -130,7 +130,9 @@ public class XmlAttr extends XmlNode {
     @JRubyMethod(name = {"value=", "content="})
     public IRubyObject value_set(ThreadContext context, IRubyObject content){
         Attr attr = (Attr) node;
-        attr.setValue(rubyStringToString(XmlNode.encode_special_chars(context, content)));
+        if (content != null && !content.isNil()) {
+            attr.setValue(rubyStringToString(XmlNode.encode_special_chars(context, content)));
+        }
         setContent(content);
         return content;
     }

data/ext/java/nokogiri/XmlDtd.java

@@ -35,9 +35,11 @@ package nokogiri;
 import static nokogiri.internals.NokogiriHelpers.getNokogiriClass;
 import static nokogiri.internals.NokogiriHelpers.nonEmptyStringOrNil;
 import static nokogiri.internals.NokogiriHelpers.stringOrNil;
-import static org.jruby.javasupport.util.RuntimeHelpers.invoke;
-import nokogiri.internals.NokogiriHelpers;
-import nokogiri.internals.SaveContextVisitor;
+import static org.jruby.runtime.Helpers.invoke;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
 
 import org.apache.xerces.xni.QName;
 import org.cyberneko.dtd.DTDConfiguration;
@@ -54,6 +56,9 @@ import org.w3c.dom.DocumentType;
 import org.w3c.dom.Element;
 import org.w3c.dom.Node;
 
+import nokogiri.internals.NokogiriHelpers;
+import nokogiri.internals.SaveContextVisitor;
+
 /**
  * Class for Nokogiri::XML::DTD
  * 
@@ -64,8 +69,6 @@ import org.w3c.dom.Node;
 
 @JRubyClass(name="Nokogiri::XML::DTD", parent="Nokogiri::XML::Node")
 public class XmlDtd extends XmlNode {
-    protected RubyArray allDecls = null;
-
     /** cache of children, Nokogiri::XML::NodeSet */
     protected IRubyObject children = null;
 
@@ -369,7 +372,6 @@ public class XmlDtd extends XmlNode {
         Ruby runtime = context.getRuntime();
 
         // initialize data structures
-        allDecls = RubyArray.newArray(runtime);
         attributes = RubyHash.newHash(runtime);
         elements = RubyHash.newHash(runtime);
         entities = RubyHash.newHash(runtime);
@@ -379,10 +381,9 @@ public class XmlDtd extends XmlNode {
 
         // recursively extract decls
         if (node == null) return; // leave all the decl hash's empty
-        extractDecls(context, node.getFirstChild());
 
         // convert allDecls to a NodeSet
-        children = XmlNodeSet.newXmlNodeSet(context, allDecls);
+        children = XmlNodeSet.newXmlNodeSet(context, extractDecls(context, node.getFirstChild()));
 
         // add attribute decls as attributes to the matching element decl
         RubyArray keys = attributes.keys();
@@ -425,25 +426,26 @@ public class XmlDtd extends XmlNode {
      * subset it extracts everything and assumess <code>node</code>
      * and all children are part of the external subset.
      */
-    protected void extractDecls(ThreadContext context, Node node) {
+    protected IRubyObject[] extractDecls(ThreadContext context, Node node) {
+        List<IRubyObject> decls = new ArrayList<IRubyObject>();
         while (node != null) {
             if (isExternalSubset(node)) {
-                return;
+                break;
             } else if (isAttributeDecl(node)) {
                 XmlAttributeDecl decl = (XmlAttributeDecl)
                     XmlAttributeDecl.create(context, node);
                 attributes.op_aset(context, decl.attribute_name(context), decl);
-                allDecls.append(decl);
+                decls.add(decl);
             } else if (isElementDecl(node)) {
                 XmlElementDecl decl = (XmlElementDecl)
                     XmlElementDecl.create(context, node);
                 elements.op_aset(context, decl.element_name(context), decl);
-                allDecls.append(decl);
+                decls.add(decl);
             } else if (isEntityDecl(node)) {
                 XmlEntityDecl decl = (XmlEntityDecl)
                     XmlEntityDecl.create(context, node);
                 entities.op_aset(context, decl.node_name(context), decl);
-                allDecls.append(decl);
+                decls.add(decl);
             } else if (isNotationDecl(node)) {
                 XmlNode tmp = (XmlNode)
                     NokogiriHelpers.constructNode(context.getRuntime(), node);
@@ -453,7 +455,7 @@ public class XmlDtd extends XmlNode {
                                           tmp.getAttribute(context, "sysid"));
                 notations.op_aset(context,
                                   tmp.getAttribute(context, "name"), decl);
-                allDecls.append(decl);
+                decls.add(decl);
             } else if (isContentModel(node)) {
                 XmlElementContent cm =
                     new XmlElementContent(context.getRuntime(),
@@ -462,13 +464,15 @@ public class XmlDtd extends XmlNode {
                 contentModels.op_aset(context, cm.element_name(context), cm);
             } else {
                 // recurse
-                extractDecls(context, node.getFirstChild());
+                decls.addAll(Arrays.asList(extractDecls(context, node.getFirstChild())));
             }
 
             node = node.getNextSibling();
         }
+
+        return decls.toArray(new IRubyObject[decls.size()]);
     }
-    
+
     @Override
     public void accept(ThreadContext context, SaveContextVisitor visitor) {
         // since we use nekoDTD to parse dtd, node might be ElementImpl type

data/ext/java/nokogiri/XmlElement.java

@@ -32,16 +32,16 @@
 
 package nokogiri;
 
-import nokogiri.internals.SaveContextVisitor;
-
 import org.jruby.Ruby;
-import org.jruby.RubyArray;
 import org.jruby.RubyClass;
 import org.jruby.anno.JRubyClass;
 import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
 import org.w3c.dom.Element;
 import org.w3c.dom.Node;
 
+import nokogiri.internals.SaveContextVisitor;
+
 /**
  * Class for Nokogiri::XML::Element
  * 
@@ -71,9 +71,9 @@ public class XmlElement extends XmlNode {
         visitor.enter((Element) node);
         XmlNodeSet xmlNodeSet = (XmlNodeSet) children(context);
         if (xmlNodeSet.length() > 0) {
-            RubyArray nodes = xmlNodeSet.nodes;
-            for( int i = 0; i < nodes.size(); i++ ) {
-                Object item = nodes.eltInternal(i);
+            IRubyObject[] nodes = XmlNodeSet.getNodes(context, xmlNodeSet);
+            for( int i = 0; i < nodes.length; i++ ) {
+                Object item = nodes[i];
                 if (item instanceof XmlNode) {
                     ((XmlNode) item).accept(context, visitor);
                 }

data/ext/java/nokogiri/XmlNode.java

@@ -472,10 +472,31 @@ public class XmlNode extends RubyObject {
         String nsURI = e.lookupNamespaceURI(prefix);
         this.node = NokogiriHelpers.renameNode(e, nsURI, e.getNodeName());
 
-        if (nsURI == null || nsURI.isEmpty()) {
+        if (nsURI == null || nsURI == "") {
             return;
         }
 
+        String currentPrefix = e.getParentNode().lookupPrefix(nsURI);
+        String currentURI = e.getParentNode().lookupNamespaceURI(prefix);
+        boolean isDefault = e.getParentNode().isDefaultNamespace(nsURI);
+
+        // add xmlns attribute if this is a new root node or if the node's
+        // namespace isn't a default namespace in the new document
+        if (e.getParentNode().getNodeType() == Node.DOCUMENT_NODE) {
+          // this is the root node, so we must set the namespaces attributes
+          // anyway
+          e.setAttribute(prefix == null ? "xmlns":"xmlns:"+prefix, nsURI);
+        } else if (prefix == null) {
+           if (!isDefault)
+             // this is a default namespace but isn't the default where this
+             // node is being added
+             e.setAttribute("xmlns", nsURI);
+        } else if (currentPrefix != prefix || currentURI != nsURI) {
+          // this is a prefixed namespace but doens't have the same prefix or
+          // the prefix is set to a diffent URI
+          e.setAttribute("xmlns:"+prefix, nsURI);
+        }
+
         if (e.hasAttributes()) {
             NamedNodeMap attrs = e.getAttributes();
 
@@ -704,7 +725,7 @@ public class XmlNode extends RubyObject {
 
     @JRubyMethod
     public IRubyObject children(ThreadContext context) {
-        XmlNodeSet xmlNodeSet = XmlNodeSet.create(context.runtime);
+        XmlNodeSet xmlNodeSet = XmlNodeSet.newEmptyNodeSet(context);
 
         NodeList nodeList = node.getChildNodes();
         if (nodeList.getLength() > 0) {
@@ -737,8 +758,8 @@ public class XmlNode extends RubyObject {
     public IRubyObject element_children(ThreadContext context) {
         List<Node> elementNodes = new ArrayList<Node>();
         addElements(node, elementNodes, false);
-        if (elementNodes.size() == 0) return XmlNodeSet.newEmptyNodeSet(context);
-        RubyArray array = NokogiriHelpers.nodeArrayToRubyArray(context.getRuntime(), elementNodes.toArray(new Node[0]));
+        IRubyObject[] array = NokogiriHelpers.nodeArrayToArray(context.runtime,
+                                                               elementNodes.toArray(new Node[0]));
         XmlNodeSet xmlNodeSet = XmlNodeSet.newXmlNodeSet(context, array);
         return xmlNodeSet;
     }
@@ -839,10 +860,10 @@ public class XmlNode extends RubyObject {
         RubyArray docErrors = getErrorArray(doc);
         if (isErrorIncreased(documentErrors, docErrors)) {
             for (int i = 0; i < docErrors.getLength(); i++) {
-                documentErrors.add(docErrors.get(i));
+                documentErrors.add(docErrors.entry(i));
             }
             document.setInstanceVariable("@errors", documentErrors);
-            XmlNodeSet xmlNodeSet = XmlNodeSet.newXmlNodeSet(context, RubyArray.newArray(runtime));
+            XmlNodeSet xmlNodeSet = XmlNodeSet.newXmlNodeSet(context, new IRubyObject[0]);
             return xmlNodeSet;
         }
 
@@ -854,10 +875,9 @@ public class XmlNode extends RubyObject {
         } else {
             first = doc.node.getFirstChild();
         }
-        RubyArray nodeArray = RubyArray.newArray(runtime);
-        nodeArray.add(NokogiriHelpers.getCachedNodeOrCreate(runtime, first));
 
-        XmlNodeSet xmlNodeSet = XmlNodeSet.newXmlNodeSet(context, nodeArray);
+        IRubyObject[] nodes = new IRubyObject[]{NokogiriHelpers.getCachedNodeOrCreate(runtime, first)};
+        XmlNodeSet xmlNodeSet = XmlNodeSet.newXmlNodeSet(context, nodes);
         return xmlNodeSet;
     }
 

data/ext/java/nokogiri/XmlNodeSet.java

@@ -17,10 +17,10 @@
  * 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.
@@ -36,12 +36,13 @@ import static nokogiri.XmlNode.setDocumentAndDecorate;
 import static nokogiri.internals.NokogiriHelpers.getNokogiriClass;
 import static nokogiri.internals.NokogiriHelpers.nodeListToRubyArray;
 
-import java.util.List;
+import java.util.Arrays;
 
 import org.jruby.Ruby;
-import org.jruby.RubyArray;
 import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
 import org.jruby.RubyObject;
+import org.jruby.RubyRange;
 import org.jruby.anno.JRubyClass;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.runtime.Block;
@@ -59,30 +60,38 @@ import org.w3c.dom.NodeList;
 @JRubyClass(name="Nokogiri::XML::NodeSet")
 public class XmlNodeSet extends RubyObject implements NodeList {
 
-    RubyArray nodes;
-    
+    private IRubyObject[] nodes;
+
+    @JRubyMethod(name = "new", meta = true, rest = true)
+    public static IRubyObject rbNew(ThreadContext context, IRubyObject cls,
+                                    IRubyObject[] args, Block block) {
+      RubyClass klass = (RubyClass) cls;
+      XmlNodeSet set = (XmlNodeSet) klass.allocate();
+      set.setNodes(new IRubyObject[0]);
+      set.callInit(args, block);
+      return set;
+    }
+
     public XmlNodeSet(Ruby ruby, RubyClass klazz) {
         super(ruby, klazz);
     }
 
-    public static XmlNodeSet create(final Ruby runtime) {
+    private static XmlNodeSet create(final Ruby runtime) {
         return (XmlNodeSet) NokogiriService.XML_NODESET_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::NodeSet"));
     }
 
     public static XmlNodeSet newEmptyNodeSet(ThreadContext context) {
-        return create(context.getRuntime());
+        XmlNodeSet set = create(context.getRuntime());
+        set.nodes = new IRubyObject[0];
+        return set;
     }
 
-    public static XmlNodeSet newXmlNodeSet(final Ruby runtime, RubyArray nodes) {
-        XmlNodeSet xmlNodeSet = create(runtime);
+    public static XmlNodeSet newXmlNodeSet(ThreadContext context, IRubyObject[] nodes) {
+        XmlNodeSet xmlNodeSet = create(context.runtime);
         xmlNodeSet.setNodes(nodes);
         return xmlNodeSet;
     }
 
-    static XmlNodeSet newXmlNodeSet(ThreadContext context, RubyArray nodes) {
-        return newXmlNodeSet(context.getRuntime(), nodes);
-    }
-
     /**
      * Create and return a copy of this object.
      *
@@ -93,19 +102,18 @@ public class XmlNodeSet extends RubyObject implements NodeList {
         return super.clone();
     }
 
-    void setNodes(RubyArray array) {
+    void setNodes(IRubyObject[] array) {
         this.nodes = array;
 
-        IRubyObject first = array.first();
-        initialize(array.getRuntime(), first);
+        IRubyObject first = array.length > 0 ? array[0] : null;
+        initialize(getRuntime(), first);
     }
 
     private void setReference(XmlNodeSet reference) {
-        this.nodes = null;
-        IRubyObject first = reference.nodes.first();
-        initialize(reference.getRuntime(), first);
+        IRubyObject first = reference.nodes.length > 0 ? reference.nodes[0] : null;
+        initialize(getRuntime(), first);
     }
-    
+
     public void setNodeList(NodeList nodeList) {
         setNodes(nodeListToRubyArray(getRuntime(), nodeList));
     }
@@ -118,106 +126,280 @@ public class XmlNodeSet extends RubyObject implements NodeList {
     }
 
     public int length() {
-        if (nodes == null) return 0;
-        return nodes.size();
+      return nodes == null ? 0 : nodes.length;
     }
 
     public void relink_namespace(ThreadContext context) {
-        List<?> n = nodes.getList();
-
-        for (int i = 0; i < n.size(); i++) {
-            if (n.get(i) instanceof XmlNode) {
-                ((XmlNode) n.get(i)).relink_namespace(context);
+        for (int i = 0; i < nodes.length; i++) {
+            if (nodes[i] instanceof XmlNode) {
+                ((XmlNode) nodes[i]).relink_namespace(context);
             }
         }
     }
 
     @JRubyMethod(name="&")
-    public IRubyObject and(ThreadContext context, IRubyObject nodeSet) {
-        if (nodes == null) setNodes(RubyArray.newEmptyArray(context.getRuntime()));
-        return newXmlNodeSet(context, (RubyArray) nodes.op_and(getNodes(context, nodeSet)));
+    public IRubyObject op_and(ThreadContext context, IRubyObject nodeSet) {
+        IRubyObject[] otherNodes = getNodes(context, nodeSet);
+
+        if (otherNodes == null || otherNodes.length == 0) {
+          return newEmptyNodeSet(context);
+        }
+
+        if (nodes == null || nodes.length == 0) {
+          return newEmptyNodeSet(context);
+        }
+
+        IRubyObject[] curr = nodes;
+        IRubyObject[] other = getNodes(context, nodeSet);
+        IRubyObject[] result = new IRubyObject[nodes.length];
+
+        int last = 0;
+outer:
+        for (int i = 0; i < curr.length; i++) {
+          IRubyObject n = curr[i];
+
+          for (int j = 0; j < other.length; j++) {
+            if (other[j] == n) {
+              result[last++] = n;
+              continue outer;
+            }
+          }
+        }
+
+        XmlNodeSet newSet = newXmlNodeSet(context, Arrays.copyOf(result, last));
+        newSet.setReference(this);
+        return newSet;
     }
 
     @JRubyMethod
     public IRubyObject delete(ThreadContext context, IRubyObject node_or_namespace) {
-        if (nodes == null) return context.getRuntime().getNil();
-        if (node_or_namespace instanceof XmlNamespace) {
-            ((XmlNamespace) node_or_namespace).deleteHref();
+        IRubyObject nodeOrNamespace = asXmlNodeOrNamespace(context, node_or_namespace);
+
+        if (nodes.length == 0) {
+          return context.nil;
+        }
+
+        IRubyObject[] orig = nodes;
+        IRubyObject[] result = new IRubyObject[nodes.length];
+
+        int last = 0;
+
+        for (int i = 0; i < orig.length; i++) {
+          IRubyObject n = orig[i];
+
+          if (n == nodeOrNamespace) {
+            continue;
+          }
+
+          result[last++] = n;
         }
-        return nodes.delete(context, asXmlNodeOrNamespace(context, node_or_namespace), Block.NULL_BLOCK);
+
+        if (nodeOrNamespace instanceof XmlNamespace) {
+          ((XmlNamespace) nodeOrNamespace).deleteHref();
+        }
+
+        nodes = Arrays.copyOf(result, last);
+
+        if (nodes.length < orig.length) {
+          // if we found the node return it
+          return nodeOrNamespace;
+        }
+
+        return context.nil;
     }
 
     @JRubyMethod
-    public IRubyObject dup(ThreadContext context){
-        if (nodes == null) return newEmptyNodeSet(context);
-        return newXmlNodeSet(context, nodes.aryDup());
+    public IRubyObject dup(ThreadContext context) {
+        return newXmlNodeSet(context, nodes);
     }
 
     @JRubyMethod(name = "include?")
     public IRubyObject include_p(ThreadContext context, IRubyObject node_or_namespace) {
-        node_or_namespace = asXmlNodeOrNamespace(context, node_or_namespace);
-        if (nodes == null) return context.getRuntime().getFalse();
-        return nodes.include_p(context, node_or_namespace);
+        for (int i = 0; i < nodes.length; i++) {
+          if (nodes[i] == node_or_namespace) {
+            return context.tru;
+          }
+        }
+
+        return context.runtime.getFalse();
     }
 
     @JRubyMethod(name = {"length", "size"})
     public IRubyObject length(ThreadContext context) {
-        return nodes != null ? nodes.length() : context.getRuntime().newFixnum(0);
+        return context.getRuntime().newFixnum(nodes.length);
     }
 
     @JRubyMethod(name="-")
     public IRubyObject op_diff(ThreadContext context, IRubyObject nodeSet) {
-        XmlNodeSet xmlNodeSet = newXmlNodeSet(context, this);
-        if (nodes == null) setNodes(RubyArray.newEmptyArray(context.getRuntime()));
-        xmlNodeSet.setNodes((RubyArray) nodes.op_diff(getNodes(context, nodeSet)));
-        return xmlNodeSet;
+        IRubyObject[] otherNodes = getNodes(context, nodeSet);
+
+        if (otherNodes.length == 0) {
+          return dup(context);
+        }
+
+        if (nodes.length == 0) {
+          return newEmptyNodeSet(context);
+        }
+
+        IRubyObject[] curr = nodes;
+        IRubyObject[] other = getNodes(context, nodeSet);
+        IRubyObject[] result = new IRubyObject[nodes.length];
+
+        int last = 0;
+outer:
+        for (int i = 0; i < curr.length; i++) {
+          IRubyObject n = curr[i];
+
+          for (int j = 0; j < other.length; j++) {
+            if (other[j] == n) {
+              continue outer;
+            }
+          }
+
+          result[last++] = n;
+        }
+
+        XmlNodeSet newSet = newXmlNodeSet(context, Arrays.copyOf(result, last));
+        newSet.setReference(this);
+        return newSet;
     }
 
     @JRubyMethod(name={"|", "+"})
     public IRubyObject op_or(ThreadContext context, IRubyObject nodeSet) {
-        if (nodes == null) setNodes(RubyArray.newEmptyArray(context.getRuntime()));
-        return newXmlNodeSet(context, (RubyArray) nodes.op_or(getNodes(context, nodeSet)));
+        IRubyObject[] otherNodes = getNodes(context, nodeSet);
+
+        if (nodes.length == 0) {
+          return ((XmlNodeSet) nodeSet).dup(context);
+        }
+
+        if (otherNodes.length == 0) {
+          return dup(context);
+        }
+
+        IRubyObject[] curr = nodes;
+        IRubyObject[] other = getNodes(context, nodeSet);
+        IRubyObject[] result = Arrays.copyOf(curr, curr.length + other.length);
+
+        int last = curr.length;
+outer:
+        for (int i = 0; i < other.length; i++) {
+          IRubyObject n = other[i];
+
+          for (int j = 0; j < curr.length; j++) {
+            if (curr[j] == n) {
+              continue outer;
+            }
+          }
+
+          result[last++] = n;
+        }
+
+        XmlNodeSet newSet = newXmlNodeSet(context, Arrays.copyOf(result, last));
+        newSet.setReference(this);
+        return newSet;
     }
 
     @JRubyMethod(name = {"push", "<<"})
     public IRubyObject push(ThreadContext context, IRubyObject node_or_namespace) {
-        if (nodes == null) setNodes(RubyArray.newArray(context.getRuntime()));
-        nodes.append(asXmlNodeOrNamespace(context, node_or_namespace));
+        nodes = Arrays.copyOf(nodes, nodes.length+1);
+        nodes[nodes.length-1] = node_or_namespace;
         return this;
     }
 
+    //  replace with
+    //  https://github.com/jruby/jruby/blame/13a3ec76d883a162b9d46c374c6e9eeea27b3261/core/src/main/java/org/jruby/RubyRange.java#L974
+    //  once we upgraded the min JRuby version to >= 9.2
+    private static IRubyObject rangeBeginLength(ThreadContext context, IRubyObject rangeMaybe, int len, int[] begLen) {
+        RubyRange range = (RubyRange) rangeMaybe;
+        int min = range.begin(context).convertToInteger().getIntValue();
+        int max = range.end(context).convertToInteger().getIntValue();
+
+        if (min < 0) {
+          min += len;
+          if (min < 0) {
+            throw context.runtime.newRangeError(min + ".." + (range.isExcludeEnd() ? "." : "") + max + " out of range");
+          }
+        }
+
+        if (max < 0) {
+          max += len;
+        }
+
+        if (!range.isExcludeEnd()) {
+          max++;
+        }
+
+        begLen[0] = min;
+        begLen[1] = max;
+        return context.tru;
+    }
+
+
     @JRubyMethod(name={"[]", "slice"})
-    public IRubyObject slice(ThreadContext context, IRubyObject indexOrRange){
-        if (nodes == null) return context.getRuntime().getNil();
-        IRubyObject result = nodes.aref19(indexOrRange);
-        if (result instanceof RubyArray) {
-            return newXmlNodeSet(context, (RubyArray) result);
+    public IRubyObject slice(ThreadContext context, IRubyObject indexOrRange) {
+        if (indexOrRange instanceof RubyFixnum) {
+          int idx = ((RubyFixnum)indexOrRange).getIntValue();
+
+          if (idx < 0) {
+            idx += nodes.length;
+          }
+
+          if (idx >= nodes.length || idx < 0) {
+            return context.nil;
+          }
+
+          return nodes[idx];
         }
-        return result;
+
+        int[] begLen = new int[2];
+        rangeBeginLength(context, indexOrRange, nodes.length, begLen);
+        int min = begLen[0];
+        int max = begLen[1];
+        return subseq(context, min, max - min);
     }
 
     @JRubyMethod(name={"[]", "slice"})
-    public IRubyObject slice(ThreadContext context, IRubyObject start, IRubyObject length){
-        if (nodes == null) return context.getRuntime().getNil();
-        IRubyObject result = nodes.aref19(start, length);
-        if (result instanceof RubyArray) {
-            return newXmlNodeSet(context, (RubyArray) result);
+    public IRubyObject slice(ThreadContext context, IRubyObject start, IRubyObject length) {
+        int s = ((RubyFixnum) start).getIntValue();
+        int l = ((RubyFixnum) length).getIntValue();
+
+        if (s < 0) {
+          s += nodes.length;
         }
-        return context.getRuntime().getNil();
+
+        return subseq(context, s, l);
+    }
+
+    public IRubyObject subseq(ThreadContext context, int start, int length) {
+        if (start > nodes.length) {
+          return context.nil;
+        }
+
+        if (start < 0 || length < 0) {
+          return context.nil;
+        }
+
+        if (start + length > nodes.length) {
+          length = nodes.length - start;
+        }
+
+        int to = start + length;
+
+        IRubyObject[] newNodes = Arrays.copyOfRange(nodes, start, to);
+
+        return newXmlNodeSet(context, newNodes);
     }
 
     @JRubyMethod(name = {"to_a", "to_ary"})
     public IRubyObject to_a(ThreadContext context) {
-        return nodes;
+        return context.runtime.newArrayNoCopy(nodes);
     }
 
     @JRubyMethod(name = {"unlink", "remove"})
-    public IRubyObject unlink(ThreadContext context){
-        if (nodes == null) return this;
-        IRubyObject[] arr = nodes.toJavaArrayUnsafe();
-        for (int i = 0; i < arr.length; i++) {
-            if (arr[i] instanceof XmlNode) {
-                ((XmlNode) arr[i] ).unlink(context);
+    public IRubyObject unlink(ThreadContext context) {
+        for (int i = 0; i < nodes.length; i++) {
+            if (nodes[i] instanceof XmlNode) {
+                ((XmlNode) nodes[i] ).unlink(context);
             }
         }
         return this;
@@ -226,6 +408,7 @@ public class XmlNodeSet extends RubyObject implements NodeList {
     private static XmlNodeSet newXmlNodeSet(ThreadContext context, XmlNodeSet reference) {
         XmlNodeSet xmlNodeSet = create(context.getRuntime());
         xmlNodeSet.setReference(reference);
+        xmlNodeSet.nodes = new IRubyObject[0];
         return xmlNodeSet;
     }
 
@@ -236,21 +419,19 @@ public class XmlNodeSet extends RubyObject implements NodeList {
         throw context.getRuntime().newArgumentError("node must be a Nokogiri::XML::Node or Nokogiri::XML::Namespace");
     }
 
-    private static RubyArray getNodes(ThreadContext context, IRubyObject possibleNodeSet) {
+    static IRubyObject[] getNodes(ThreadContext context, IRubyObject possibleNodeSet) {
         if (possibleNodeSet instanceof XmlNodeSet) {
-            RubyArray nodes = ((XmlNodeSet) possibleNodeSet).nodes;
-            return nodes == null ? RubyArray.newEmptyArray(context.getRuntime()) : nodes;
+            return ((XmlNodeSet) possibleNodeSet).nodes;
         }
         throw context.getRuntime().newArgumentError("node must be a Nokogiri::XML::NodeSet");
     }
-    
+
     public int getLength() {
-        return nodes == null ? 0 : nodes.size();
+        return nodes.length;
     }
-    
+
     public Node item(int index) {
-        if (nodes == null) return null;
-        Object n = nodes.get(index);
+        Object n = nodes[index];
         if (n instanceof XmlNode) return ((XmlNode)n).node;
         if (n instanceof XmlNamespace) return ((XmlNamespace)n).getNode();
         return null;