nokogiri 1.10.8-java → 1.11.0.rc3-java

data/ext/java/nokogiri/XmlNodeSet.java

@@ -39,13 +39,13 @@ import static nokogiri.internals.NokogiriHelpers.nodeListToRubyArray;
 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;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.w3c.dom.Node;
@@ -60,38 +60,44 @@ import org.w3c.dom.NodeList;
 @JRubyClass(name="Nokogiri::XML::NodeSet")
 public class XmlNodeSet extends RubyObject implements NodeList {
 
-    private IRubyObject[] nodes;
+    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);
+        nodes = IRubyObject.NULL_ARRAY;
     }
 
-    public XmlNodeSet(Ruby ruby, RubyClass klazz) {
+    XmlNodeSet(Ruby ruby, RubyClass klazz, IRubyObject[] nodes) {
         super(ruby, klazz);
+        this.nodes = nodes;
     }
 
-    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, XmlNodeSet docOwner) {
+        final Ruby runtime = context.runtime;
+        XmlNodeSet set = new XmlNodeSet(runtime, getNokogiriClass(runtime, "Nokogiri::XML::NodeSet"));
+        set.initializeFrom(context, docOwner);
+        return set;
     }
 
-    public static XmlNodeSet newEmptyNodeSet(ThreadContext context) {
-        XmlNodeSet set = create(context.getRuntime());
-        set.nodes = new IRubyObject[0];
+    public static XmlNodeSet newEmptyNodeSet(ThreadContext context, XmlNode docOwner) {
+        final Ruby runtime = context.runtime;
+        XmlNodeSet set = new XmlNodeSet(runtime, getNokogiriClass(runtime, "Nokogiri::XML::NodeSet"));
+        set.initialize(runtime, docOwner);
         return set;
     }
 
-    public static XmlNodeSet newXmlNodeSet(ThreadContext context, IRubyObject[] nodes) {
-        XmlNodeSet xmlNodeSet = create(context.runtime);
+    public static XmlNodeSet newNodeSet(Ruby runtime, IRubyObject[] nodes) {
+        XmlNodeSet xmlNodeSet = new XmlNodeSet(runtime, getNokogiriClass(runtime, "Nokogiri::XML::NodeSet"));
         xmlNodeSet.setNodes(nodes);
         return xmlNodeSet;
     }
 
+    public static XmlNodeSet newNodeSet(Ruby runtime, IRubyObject[] nodes, XmlNode docOwner) {
+        XmlNodeSet set = new XmlNodeSet(runtime, getNokogiriClass(runtime, "Nokogiri::XML::NodeSet"), nodes);
+        set.initialize(runtime, docOwner);
+        return set;
+    }
+
     /**
      * Create and return a copy of this object.
      *
@@ -102,39 +108,33 @@ public class XmlNodeSet extends RubyObject implements NodeList {
         return super.clone();
     }
 
-    void setNodes(IRubyObject[] array) {
+    private void setNodes(IRubyObject[] array) {
         this.nodes = array;
 
         IRubyObject first = array.length > 0 ? array[0] : null;
         initialize(getRuntime(), first);
     }
 
-    private void setReference(XmlNodeSet reference) {
-        IRubyObject first = reference.nodes.length > 0 ? reference.nodes[0] : null;
-        initialize(getRuntime(), first);
-    }
-
-    public void setNodeList(NodeList nodeList) {
-        setNodes(nodeListToRubyArray(getRuntime(), nodeList));
+    private void initializeFrom(ThreadContext context, XmlNodeSet ref) {
+        IRubyObject document = ref.getInstanceVariable("@document");
+        if (document != null && !document.isNil()) {
+            initialize(context, (XmlDocument) document);
+        }
     }
 
     final void initialize(Ruby runtime, IRubyObject refNode) {
         if (refNode instanceof XmlNode) {
-            IRubyObject doc = ((XmlNode) refNode).document(runtime);
+            XmlDocument doc = ((XmlNode) refNode).document(runtime);
             setDocumentAndDecorate(runtime.getCurrentContext(), this, doc);
         }
     }
 
-    public int length() {
-      return nodes == null ? 0 : nodes.length;
+    private void initialize(ThreadContext context, XmlDocument doc) {
+        setDocumentAndDecorate(context, this, doc);
     }
 
-    public void relink_namespace(ThreadContext context) {
-        for (int i = 0; i < nodes.length; i++) {
-            if (nodes[i] instanceof XmlNode) {
-                ((XmlNode) nodes[i]).relink_namespace(context);
-            }
-        }
+    public int length() {
+        return nodes == null ? 0 : nodes.length;
     }
 
     @JRubyMethod(name="&")
@@ -142,11 +142,11 @@ public class XmlNodeSet extends RubyObject implements NodeList {
         IRubyObject[] otherNodes = getNodes(context, nodeSet);
 
         if (otherNodes == null || otherNodes.length == 0) {
-          return newEmptyNodeSet(context);
+          return newEmptyNodeSet(context, this);
         }
 
         if (nodes == null || nodes.length == 0) {
-          return newEmptyNodeSet(context);
+          return newEmptyNodeSet(context, this);
         }
 
         IRubyObject[] curr = nodes;
@@ -166,8 +166,8 @@ outer:
           }
         }
 
-        XmlNodeSet newSet = newXmlNodeSet(context, Arrays.copyOf(result, last));
-        newSet.setReference(this);
+        XmlNodeSet newSet = newNodeSet(context.runtime, Arrays.copyOf(result, last));
+        newSet.initializeFrom(context, this);
         return newSet;
     }
 
@@ -210,7 +210,9 @@ outer:
 
     @JRubyMethod
     public IRubyObject dup(ThreadContext context) {
-        return newXmlNodeSet(context, nodes);
+        XmlNodeSet dup = newNodeSet(context.runtime, nodes.clone());
+        dup.initializeFrom(context, this);
+        return dup;
     }
 
     @JRubyMethod(name = "include?")
@@ -221,12 +223,12 @@ outer:
           }
         }
 
-        return context.runtime.getFalse();
+        return context.fals;
     }
 
     @JRubyMethod(name = {"length", "size"})
     public IRubyObject length(ThreadContext context) {
-        return context.getRuntime().newFixnum(nodes.length);
+        return context.runtime.newFixnum(nodes.length);
     }
 
     @JRubyMethod(name="-")
@@ -234,11 +236,11 @@ outer:
         IRubyObject[] otherNodes = getNodes(context, nodeSet);
 
         if (otherNodes.length == 0) {
-          return dup(context);
+            return dup(context);
         }
 
         if (nodes.length == 0) {
-          return newEmptyNodeSet(context);
+            return newEmptyNodeSet(context, this);
         }
 
         IRubyObject[] curr = nodes;
@@ -259,8 +261,8 @@ outer:
           result[last++] = n;
         }
 
-        XmlNodeSet newSet = newXmlNodeSet(context, Arrays.copyOf(result, last));
-        newSet.setReference(this);
+        XmlNodeSet newSet = newNodeSet(context.runtime, Arrays.copyOf(result, last));
+        newSet.initializeFrom(context, this);
         return newSet;
     }
 
@@ -294,8 +296,8 @@ outer:
           result[last++] = n;
         }
 
-        XmlNodeSet newSet = newXmlNodeSet(context, Arrays.copyOf(result, last));
-        newSet.setReference(this);
+        XmlNodeSet newSet = newNodeSet(context.runtime, Arrays.copyOf(result, last));
+        newSet.initializeFrom(context, this);
         return newSet;
     }
 
@@ -338,17 +340,7 @@ outer:
     @JRubyMethod(name={"[]", "slice"})
     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 slice(context, ((RubyFixnum) indexOrRange).getIntValue());
         }
 
         int[] begLen = new int[2];
@@ -358,13 +350,25 @@ outer:
         return subseq(context, min, max - min);
     }
 
+    IRubyObject slice(ThreadContext context, int idx) {
+        if (idx < 0) {
+            idx += nodes.length;
+        }
+
+        if (idx >= nodes.length || idx < 0) {
+            return context.nil;
+        }
+
+        return nodes[idx];
+    }
+
     @JRubyMethod(name={"[]", "slice"})
     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;
+            s += nodes.length;
         }
 
         return subseq(context, s, l);
@@ -372,26 +376,24 @@ outer:
 
     public IRubyObject subseq(ThreadContext context, int start, int length) {
         if (start > nodes.length) {
-          return context.nil;
+            return context.nil;
         }
 
         if (start < 0 || length < 0) {
-          return context.nil;
+            return context.nil;
         }
 
         if (start + length > nodes.length) {
-          length = nodes.length - start;
+            length = nodes.length - start;
         }
 
         int to = start + length;
 
-        IRubyObject[] newNodes = Arrays.copyOfRange(nodes, start, to);
-
-        return newXmlNodeSet(context, newNodes);
+        return newNodeSet(context.runtime, Arrays.copyOfRange(nodes, start, to));
     }
 
     @JRubyMethod(name = {"to_a", "to_ary"})
-    public IRubyObject to_a(ThreadContext context) {
+    public RubyArray to_a(ThreadContext context) {
         return context.runtime.newArrayNoCopy(nodes);
     }
 
@@ -405,13 +407,6 @@ outer:
         return this;
     }
 
-    private static XmlNodeSet newXmlNodeSet(ThreadContext context, XmlNodeSet reference) {
-        XmlNodeSet xmlNodeSet = create(context.getRuntime());
-        xmlNodeSet.setReference(reference);
-        xmlNodeSet.nodes = new IRubyObject[0];
-        return xmlNodeSet;
-    }
-
     private static IRubyObject asXmlNodeOrNamespace(ThreadContext context, IRubyObject possibleNode) {
         if (possibleNode instanceof XmlNode || possibleNode instanceof XmlNamespace) {
             return possibleNode;
@@ -419,7 +414,7 @@ outer:
         throw context.getRuntime().newArgumentError("node must be a Nokogiri::XML::Node or Nokogiri::XML::Namespace");
     }
 
-    static IRubyObject[] getNodes(ThreadContext context, IRubyObject possibleNodeSet) {
+    private static IRubyObject[] getNodes(ThreadContext context, IRubyObject possibleNodeSet) {
         if (possibleNodeSet instanceof XmlNodeSet) {
             return ((XmlNodeSet) possibleNodeSet).nodes;
         }
@@ -432,8 +427,8 @@ outer:
 
     public Node item(int index) {
         Object n = nodes[index];
-        if (n instanceof XmlNode) return ((XmlNode)n).node;
-        if (n instanceof XmlNamespace) return ((XmlNamespace)n).getNode();
+        if (n instanceof XmlNode) return ((XmlNode) n).node;
+        if (n instanceof XmlNamespace) return ((XmlNamespace) n).getNode();
         return null;
     }
 }

data/ext/java/nokogiri/XmlReader.java

@@ -41,15 +41,6 @@ import java.util.LinkedList;
 import java.util.List;
 import java.util.Stack;
 
-import nokogiri.internals.NokogiriEntityResolver;
-import nokogiri.internals.ParserContext;
-import nokogiri.internals.ParserContext.Options;
-import nokogiri.internals.ReaderNode;
-import nokogiri.internals.ReaderNode.ClosingNode;
-import nokogiri.internals.ReaderNode.ElementNode;
-import nokogiri.internals.ReaderNode.TextNode;
-import nokogiri.internals.UncloseableInputStream;
-
 import org.apache.xerces.impl.Constants;
 import org.apache.xerces.impl.xs.opti.DefaultXMLDocumentHandler;
 import org.apache.xerces.parsers.StandardParserConfiguration;
@@ -81,6 +72,14 @@ import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.util.IOInputStream;
 import org.xml.sax.InputSource;
 
+import nokogiri.internals.NokogiriEntityResolver;
+import nokogiri.internals.ParserContext;
+import nokogiri.internals.ParserContext.Options;
+import nokogiri.internals.ReaderNode;
+import nokogiri.internals.ReaderNode.ClosingNode;
+import nokogiri.internals.ReaderNode.ElementNode;
+import nokogiri.internals.ReaderNode.TextNode;
+
 /**
  * Class for Nokogiri:XML::Reader
  *
@@ -217,7 +216,7 @@ public class XmlReader extends RubyObject {
           options = new ParserContext.Options(2048 | 1);
         }
 
-        InputStream in = new UncloseableInputStream(new IOInputStream(args[0]));
+        InputStream in = new IOInputStream(args[0]);
         reader.setInput(context, in, url, options);
         return reader;
     }
@@ -245,7 +244,7 @@ public class XmlReader extends RubyObject {
           options = new ParserContext.Options(2048 | 1);
         }
         IRubyObject stringIO = runtime.getClass("StringIO").newInstance(context, args[0], Block.NULL_BLOCK);
-        InputStream in = new UncloseableInputStream(new IOInputStream(stringIO));
+        InputStream in = new IOInputStream(stringIO);
         reader.setInput(context, in, url, options);
         return reader;
     }

data/ext/java/nokogiri/XmlSaxParserContext.java

@@ -37,11 +37,6 @@ import static org.jruby.runtime.Helpers.invoke;
 import java.io.IOException;
 import java.io.InputStream;
 
-import nokogiri.internals.NokogiriHandler;
-import nokogiri.internals.NokogiriHelpers;
-import nokogiri.internals.ParserContext;
-import nokogiri.internals.XmlSaxParser;
-
 import org.apache.xerces.parsers.AbstractSAXParser;
 import org.jruby.Ruby;
 import org.jruby.RubyClass;
@@ -61,6 +56,11 @@ import org.xml.sax.SAXNotRecognizedException;
 import org.xml.sax.SAXNotSupportedException;
 import org.xml.sax.SAXParseException;
 
+import nokogiri.internals.NokogiriHandler;
+import nokogiri.internals.NokogiriHelpers;
+import nokogiri.internals.ParserContext;
+import nokogiri.internals.XmlSaxParser;
+
 /**
  * Base class for the SAX parsers.
  *
@@ -126,7 +126,7 @@ public class XmlSaxParserContext extends ParserContext {
         final Ruby runtime = context.runtime;
         XmlSaxParserContext ctx = newInstance(runtime, (RubyClass) klazz);
         ctx.initialize(runtime);
-        ctx.setInputSource(context, data, runtime.getNil());
+        ctx.setStringInputSource(context, data, runtime.getNil());
         return ctx;
     }
 
@@ -160,7 +160,7 @@ public class XmlSaxParserContext extends ParserContext {
         final Ruby runtime = context.runtime;
         XmlSaxParserContext ctx = newInstance(runtime, (RubyClass) klazz);
         ctx.initialize(runtime);
-        ctx.setInputSource(context, data, runtime.getNil());
+        ctx.setIOInputSource(context, data, runtime.getNil());
         return ctx;
     }
 

data/ext/java/nokogiri/XmlSchema.java

@@ -168,11 +168,11 @@ public class XmlSchema extends RubyObject {
 
     @JRubyMethod(visibility=Visibility.PRIVATE)
     public IRubyObject validate_file(ThreadContext context, IRubyObject file) {
-        Ruby ruby = context.getRuntime();
+        Ruby runtime = context.runtime;
 
-        XmlDomParserContext ctx = new XmlDomParserContext(ruby, RubyFixnum.newFixnum(ruby, 1L));
+        XmlDomParserContext ctx = new XmlDomParserContext(runtime, RubyFixnum.newFixnum(runtime, 1L));
         ctx.setInputSourceFile(context, file);
-        XmlDocument xmlDocument = ctx.parse(context, getNokogiriClass(ruby, "Nokogiri::XML::Document"), ruby.getNil());
+        XmlDocument xmlDocument = ctx.parse(context, getNokogiriClass(runtime, "Nokogiri::XML::Document"), context.nil);
         return validate_document_or_file(context, xmlDocument);
     }
 

data/ext/java/nokogiri/XmlText.java

@@ -36,11 +36,14 @@ import static nokogiri.internals.NokogiriHelpers.getCachedNodeOrCreate;
 import static nokogiri.internals.NokogiriHelpers.rubyStringToString;
 import nokogiri.internals.SaveContextVisitor;
 
+import org.jcodings.specific.USASCIIEncoding;
 import org.jruby.Ruby;
 import org.jruby.RubyClass;
+import org.jruby.RubyString;
 import org.jruby.anno.JRubyClass;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
 import org.w3c.dom.Document;
 import org.w3c.dom.Node;
 import org.w3c.dom.Text;
@@ -54,6 +57,9 @@ import org.w3c.dom.Text;
 @JRubyClass(name="Nokogiri::XML::Text", parent="Nokogiri::XML::CharacterData")
 public class XmlText extends XmlNode {
 
+    private static final ByteList TEXT = ByteList.create("text");
+    static { TEXT.setEncoding(USASCIIEncoding.INSTANCE); }
+
     public XmlText(Ruby runtime, RubyClass rubyClass, Node node) {
         super(runtime, rubyClass, node);
     }
@@ -65,34 +71,31 @@ public class XmlText extends XmlNode {
     @Override
     protected void init(ThreadContext context, IRubyObject[] args) {
         if (args.length < 2) {
-            throw getRuntime().newArgumentError(args.length, 2);
+            throw context.runtime.newArgumentError(args.length, 2);
         }
 
         content = args[0];
         IRubyObject xNode = args[1];
 
-        XmlNode xmlNode = asXmlNode(context, xNode);
-        XmlDocument xmlDoc = (XmlDocument)xmlNode.document(context);
-        doc = xmlDoc;
-        Document document = xmlDoc.getDocument();
+        Document document = asXmlNode(context, xNode).getOwnerDocument();
         // text node content should not be encoded when it is created by Text node.
         // while content should be encoded when it is created by Element node.
         Node node = document.createTextNode(rubyStringToString(content));
-        setNode(context, node);
+        setNode(context.runtime, node);
     }
     
     @Override
     protected IRubyObject getNodeName(ThreadContext context) {
-        if (name == null) name = context.getRuntime().newString("text");
+        if (name == null) name = RubyString.newStringShared(context.runtime, TEXT);
         return name;
     }
 
     @Override
     public void accept(ThreadContext context, SaveContextVisitor visitor) {
-        visitor.enter((Text)node);
+        visitor.enter((Text) node);
         Node child = node.getFirstChild();
         while (child != null) {
-            IRubyObject nokoNode = getCachedNodeOrCreate(context.getRuntime(), child);
+            IRubyObject nokoNode = getCachedNodeOrCreate(context.runtime, child);
             if (nokoNode instanceof XmlNode) {
                 XmlNode cur = (XmlNode) nokoNode;
                 cur.accept(context, visitor);