nokogiri 1.10.9-java → 1.11.0.rc4-java

data/ext/java/nokogiri/XmlNodeSet.java

@@ -46,7 +46,6 @@ 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;
@@ -61,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.
      *
@@ -103,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="&")
@@ -143,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;
@@ -167,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;
     }
 
@@ -211,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?")
@@ -222,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="-")
@@ -235,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;
@@ -260,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;
     }
 
@@ -295,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;
     }
 
@@ -339,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];
@@ -359,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);
@@ -373,22 +376,20 @@ 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"})
@@ -406,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;
@@ -420,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;
         }
@@ -433,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;
     }
@@ -329,7 +328,7 @@ public class XmlReader extends RubyObject {
             continueParsing = config.parse(false);
         }
         catch (XNIException e) {
-            throw new RaiseException(XmlSyntaxError.createXMLSyntaxError(context.runtime, e)); // Nokogiri::XML::SyntaxError
+            throw XmlSyntaxError.createXMLSyntaxError(context.runtime, e).toThrowable(); // Nokogiri::XML::SyntaxError
         }
         catch (IOException e) {
             throw context.runtime.newRuntimeError(e.toString());
@@ -365,7 +364,7 @@ public class XmlReader extends RubyObject {
             errors.append(error);
             setInstanceVariable("@errors", errors);
 
-            throw ex != null ? ex : new RaiseException((XmlSyntaxError) error);
+            throw ex != null ? ex : ((XmlSyntaxError) error).toThrowable();
         }
         if ( ex != null ) throw ex;
         return this;

data/ext/java/nokogiri/XmlRelaxng.java

@@ -56,6 +56,7 @@ import org.jruby.Ruby;
 import org.jruby.RubyClass;
 import org.jruby.anno.JRubyClass;
 import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
 import org.w3c.dom.Document;
 import org.xml.sax.ErrorHandler;
 import org.xml.sax.SAXException;
@@ -78,11 +79,17 @@ public class XmlRelaxng extends XmlSchema {
         this.verifier = verifier;
     }
     
-    static XmlSchema createSchemaInstance(ThreadContext context, RubyClass klazz, Source source) {
+    static XmlSchema createSchemaInstance(ThreadContext context, RubyClass klazz, Source source, IRubyObject parseOptions) {
         Ruby runtime = context.getRuntime();
         XmlRelaxng xmlRelaxng = (XmlRelaxng) NokogiriService.XML_RELAXNG_ALLOCATOR.allocate(runtime, klazz);
+
+        if (parseOptions == null) {
+            parseOptions = defaultParseOptions(context.getRuntime());
+        }
+
         xmlRelaxng.setInstanceVariable("@errors", runtime.newEmptyArray());
-        
+        xmlRelaxng.setInstanceVariable("@parse_options", parseOptions);
+
         try {
             Schema schema = xmlRelaxng.getSchema(source, context);
             xmlRelaxng.setVerifier(schema.newVerifier());
@@ -128,7 +135,7 @@ public class XmlRelaxng extends XmlSchema {
             throw context.getRuntime()
                 .newRuntimeError("Could not parse document: "+ex.getMessage());
         } catch (IOException ex) {
-            throw context.getRuntime().newIOError(ex.getMessage());
+            throw context.getRuntime().newIOError(ex.getClass() + ": " + ex.getMessage());
         }
     }
     

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.
  *
@@ -94,7 +94,10 @@ public class XmlSaxParserContext extends ParserContext {
             parser = createParser();
         }
         catch (SAXException se) {
-            throw RaiseException.createNativeRaiseException(runtime, se);
+            // Unexpected failure in XML subsystem
+            RaiseException ex = runtime.newRuntimeError(se.toString());
+            ex.initCause(se);
+            throw ex;
         }
     }
 
@@ -126,7 +129,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 +163,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;
     }
 
@@ -208,7 +211,8 @@ public class XmlSaxParserContext extends ParserContext {
                 parser.setFeature(FEATURE_CONTINUE_AFTER_FATAL_ERROR, true);
             }
             catch (Exception e) {
-                throw RaiseException.createNativeRaiseException(runtime, e);
+                // Unexpected failure in XML subsystem
+                throw runtime.newRuntimeError(e.getMessage());
             }
         }
     }
@@ -261,7 +265,8 @@ public class XmlSaxParserContext extends ParserContext {
             }
         }
         catch (SAXException ex) {
-            throw RaiseException.createNativeRaiseException(runtime, ex);
+            // Unexpected failure in XML subsystem
+            throw runtime.newRuntimeError(ex.getMessage());
         }
         catch (IOException ex) {
             throw runtime.newIOErrorFromException(ex);