nokogiri 1.7.2-java → 1.8.0-java

data/ext/java/nokogiri/XmlNodeSet.java

@@ -32,6 +32,7 @@
 
 package nokogiri;
 
+import static nokogiri.XmlNode.setDocumentAndDecorate;
 import static nokogiri.internals.NokogiriHelpers.getNokogiriClass;
 import static nokogiri.internals.NokogiriHelpers.nodeListToRubyArray;
 
@@ -43,7 +44,6 @@ import org.jruby.RubyClass;
 import org.jruby.RubyObject;
 import org.jruby.anno.JRubyClass;
 import org.jruby.anno.JRubyMethod;
-import org.jruby.javasupport.util.RuntimeHelpers;
 import org.jruby.runtime.Block;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
@@ -58,14 +58,31 @@ import org.w3c.dom.NodeList;
  */
 @JRubyClass(name="Nokogiri::XML::NodeSet")
 public class XmlNodeSet extends RubyObject implements NodeList {
-    private List<?> list;
-    private RubyArray nodes;
-    private IRubyObject doc;
+
+    RubyArray nodes;
     
     public XmlNodeSet(Ruby ruby, RubyClass klazz) {
         super(ruby, klazz);
     }
 
+    public 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());
+    }
+
+    public static XmlNodeSet newXmlNodeSet(final Ruby runtime, RubyArray nodes) {
+        XmlNodeSet xmlNodeSet = create(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.
      *
@@ -92,25 +109,17 @@ public class XmlNodeSet extends RubyObject implements NodeList {
     public void setNodeList(NodeList nodeList) {
         setNodes(nodeListToRubyArray(getRuntime(), nodeList));
     }
-    
-    public void initialize(Ruby ruby, IRubyObject refNode) {
+
+    final void initialize(Ruby runtime, IRubyObject refNode) {
         if (refNode instanceof XmlNode) {
-            XmlNode n = (XmlNode)refNode;
-            doc = n.document(ruby.getCurrentContext());
-            setInstanceVariable("@document", doc);
-            if (doc != null) {
-                RuntimeHelpers.invoke(ruby.getCurrentContext(), doc, "decorate", this);
-            }
+            IRubyObject doc = ((XmlNode) refNode).document(runtime);
+            setDocumentAndDecorate(runtime.getCurrentContext(), this, doc);
         }
     }
 
-    public static IRubyObject newEmptyNodeSet(ThreadContext context) {
-        return (XmlNodeSet)NokogiriService.XML_NODESET_ALLOCATOR.allocate(context.getRuntime(), getNokogiriClass(context.getRuntime(), "Nokogiri::XML::NodeSet"));
-    }
-
-    public long length() {
-        if (nodes == null) return 0L;
-        return nodes.length().getLongValue();
+    public int length() {
+        if (nodes == null) return 0;
+        return nodes.size();
     }
 
     public void relink_namespace(ThreadContext context) {
@@ -124,86 +133,77 @@ public class XmlNodeSet extends RubyObject implements NodeList {
     }
 
     @JRubyMethod(name="&")
-    public IRubyObject and(ThreadContext context, IRubyObject nodeSet){
+    public IRubyObject and(ThreadContext context, IRubyObject nodeSet) {
         if (nodes == null) setNodes(RubyArray.newEmptyArray(context.getRuntime()));
-        return newXmlNodeSet(context, (RubyArray) nodes.op_and(asXmlNodeSet(context, nodeSet).nodes));
+        return newXmlNodeSet(context, (RubyArray) nodes.op_and(getNodes(context, nodeSet)));
     }
 
     @JRubyMethod
-    public IRubyObject delete(ThreadContext context, IRubyObject node_or_namespace){
+    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();
+            ((XmlNamespace) node_or_namespace).deleteHref();
         }
         return nodes.delete(context, asXmlNodeOrNamespace(context, node_or_namespace), Block.NULL_BLOCK);
     }
 
     @JRubyMethod
     public IRubyObject dup(ThreadContext context){
-        if (nodes == null) setNodes(RubyArray.newEmptyArray(context.getRuntime()));
+        if (nodes == null) return newEmptyNodeSet(context);
         return newXmlNodeSet(context, nodes.aryDup());
     }
 
     @JRubyMethod(name = "include?")
-    public IRubyObject include_p(ThreadContext context, IRubyObject node_or_namespace){
-        if (nodes == null) setNodes(RubyArray.newEmptyArray(context.getRuntime()));
-        return nodes.include_p(context, asXmlNodeOrNamespace(context, node_or_namespace));
+    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);
     }
 
     @JRubyMethod(name = {"length", "size"})
     public IRubyObject length(ThreadContext context) {
-        if (nodes != null) return nodes.length();
-        else return context.getRuntime().newFixnum(0);
+        return nodes != null ? nodes.length() : context.getRuntime().newFixnum(0);
     }
 
     @JRubyMethod(name="-")
-    public IRubyObject op_diff(ThreadContext context, IRubyObject nodeSet){
+    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(asXmlNodeSet(context, nodeSet).nodes));
+        xmlNodeSet.setNodes((RubyArray) nodes.op_diff(getNodes(context, nodeSet)));
         return xmlNodeSet;
     }
 
     @JRubyMethod(name={"|", "+"})
-    public IRubyObject op_or(ThreadContext context, IRubyObject nodeSet){
+    public IRubyObject op_or(ThreadContext context, IRubyObject nodeSet) {
         if (nodes == null) setNodes(RubyArray.newEmptyArray(context.getRuntime()));
-        return newXmlNodeSet(context, (RubyArray) nodes.op_or(asXmlNodeSet(context, nodeSet).nodes));
+        return newXmlNodeSet(context, (RubyArray) nodes.op_or(getNodes(context, nodeSet)));
     }
 
     @JRubyMethod(name = {"push", "<<"})
     public IRubyObject push(ThreadContext context, IRubyObject node_or_namespace) {
-        if (nodes == null) setNodes(RubyArray.newEmptyArray(context.getRuntime()));
+        if (nodes == null) setNodes(RubyArray.newArray(context.getRuntime()));
         nodes.append(asXmlNodeOrNamespace(context, node_or_namespace));
         return this;
     }
 
     @JRubyMethod(name={"[]", "slice"})
     public IRubyObject slice(ThreadContext context, IRubyObject indexOrRange){
-        IRubyObject result;
         if (nodes == null) return context.getRuntime().getNil();
-        if (context.getRuntime().is1_9()) {
-            result = nodes.aref19(indexOrRange);
-        } else {
-            result = nodes.aref(indexOrRange);
-        }
+        IRubyObject result = nodes.aref19(indexOrRange);
         if (result instanceof RubyArray) {
-            return newXmlNodeSet(context, (RubyArray)result);
-        } else {
-            return result;
+            return newXmlNodeSet(context, (RubyArray) result);
         }
+        return result;
     }
 
     @JRubyMethod(name={"[]", "slice"})
     public IRubyObject slice(ThreadContext context, IRubyObject start, IRubyObject length){
-        IRubyObject result;
         if (nodes == null) return context.getRuntime().getNil();
-        if (context.getRuntime().is1_9()) {
-            result = nodes.aref19(start, length);
-        } else {
-            result = nodes.aref(start, length);
+        IRubyObject result = nodes.aref19(start, length);
+        if (result instanceof RubyArray) {
+            return newXmlNodeSet(context, (RubyArray) result);
         }
-        if (result instanceof RubyArray) return newXmlNodeSet(context, (RubyArray)result);
-        else return context.getRuntime().getNil();
+        return context.getRuntime().getNil();
     }
 
     @JRubyMethod(name = {"to_a", "to_ary"})
@@ -213,10 +213,9 @@ public class XmlNodeSet extends RubyObject implements NodeList {
 
     @JRubyMethod(name = {"unlink", "remove"})
     public IRubyObject unlink(ThreadContext context){
-        if (nodes == null) setNodes(RubyArray.newEmptyArray(context.getRuntime()));
-        IRubyObject[] arr = this.nodes.toJavaArrayUnsafe();
-        long length = arr.length;
-        for (int i = 0; i < length; i++) {
+        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);
             }
@@ -224,44 +223,33 @@ public class XmlNodeSet extends RubyObject implements NodeList {
         return this;
     }
 
-    public static XmlNodeSet newXmlNodeSet(ThreadContext context, RubyArray array) {
-        XmlNodeSet xmlNodeSet = (XmlNodeSet)NokogiriService.XML_NODESET_ALLOCATOR.allocate(context.getRuntime(), getNokogiriClass(context.getRuntime(), "Nokogiri::XML::NodeSet"));
-        xmlNodeSet.setNodes(array);
-        return xmlNodeSet;
-    }
-
-    private XmlNodeSet newXmlNodeSet(ThreadContext context, XmlNodeSet reference) {
-        XmlNodeSet xmlNodeSet = (XmlNodeSet)NokogiriService.XML_NODESET_ALLOCATOR.allocate(context.getRuntime(), getNokogiriClass(context.getRuntime(), "Nokogiri::XML::NodeSet"));
+    private static XmlNodeSet newXmlNodeSet(ThreadContext context, XmlNodeSet reference) {
+        XmlNodeSet xmlNodeSet = create(context.getRuntime());
         xmlNodeSet.setReference(reference);
         return xmlNodeSet;
     }
 
-    private IRubyObject asXmlNodeOrNamespace(ThreadContext context, IRubyObject possibleNode) {
+    private static IRubyObject asXmlNodeOrNamespace(ThreadContext context, IRubyObject possibleNode) {
         if (possibleNode instanceof XmlNode || possibleNode instanceof XmlNamespace) {
             return possibleNode;
-        } else {
-            throw context.getRuntime().newArgumentError("node must be a Nokogiri::XML::Node or Nokogiri::XML::Namespace");
         }
+        throw context.getRuntime().newArgumentError("node must be a Nokogiri::XML::Node or Nokogiri::XML::Namespace");
     }
 
-    private XmlNodeSet asXmlNodeSet(ThreadContext context, IRubyObject possibleNodeSet) {
-//        if(!(possibleNodeSet instanceof XmlNodeSet)) {
-        if(!RuntimeHelpers.invoke(context, possibleNodeSet, "is_a?",
-                getNokogiriClass(context.getRuntime(), "Nokogiri::XML::NodeSet")).isTrue()) {
-            throw context.getRuntime().newArgumentError("node must be a Nokogiri::XML::NodeSet");
+    private static RubyArray getNodes(ThreadContext context, IRubyObject possibleNodeSet) {
+        if (possibleNodeSet instanceof XmlNodeSet) {
+            RubyArray nodes = ((XmlNodeSet) possibleNodeSet).nodes;
+            return nodes == null ? RubyArray.newEmptyArray(context.getRuntime()) : nodes;
         }
-        XmlNodeSet xmlNodeSet = (XmlNodeSet)possibleNodeSet;
-        if (xmlNodeSet.nodes == null) xmlNodeSet.setNodes(RubyArray.newEmptyArray(context.getRuntime()));
-        return xmlNodeSet;
+        throw context.getRuntime().newArgumentError("node must be a Nokogiri::XML::NodeSet");
     }
     
     public int getLength() {
-        if (nodes == null) return 0 ;
-        return nodes.size();
+        return nodes == null ? 0 : nodes.size();
     }
     
     public Node item(int index) {
-        if (nodes == null) return null ;
+        if (nodes == null) return null;
         Object n = nodes.get(index);
         if (n instanceof XmlNode) return ((XmlNode)n).node;
         if (n instanceof XmlNamespace) return ((XmlNamespace)n).getNode();

data/ext/java/nokogiri/XmlReader.java

@@ -244,7 +244,7 @@ public class XmlReader extends RubyObject {
           // use the default options RECOVER | NONET
           options = new ParserContext.Options(2048 | 1);
         }
-        IRubyObject stringIO = NokogiriService.getNokogiriClassCache(context.getRuntime()).get("StringIO").newInstance(context, args[0], Block.NULL_BLOCK);
+        IRubyObject stringIO = runtime.getClass("StringIO").newInstance(context, args[0], Block.NULL_BLOCK);
         InputStream in = new UncloseableInputStream(new IOInputStream(stringIO));
         reader.setInput(context, in, url, options);
         return reader;
@@ -280,15 +280,15 @@ public class XmlReader extends RubyObject {
 
     private String getOuterXml() {
         ReaderNode current = currentNode();
-        if (current.depth < 0) return null;
+        if (current == null || current.depth < 0) return null;
 
         if (current instanceof ClosingNode) {
-          return "<" + current.name + "/>";
+            return "<" + current.name + "/>";
         }
 
-        StringBuffer sb = new StringBuffer();
+        StringBuilder sb = new StringBuilder();
         for (int i = position; i <= current.endOffset; i++) {
-          sb.append(nodeQueue.get(i).getString());
+            sb.append(nodeQueue.get(i).getString());
         }
         return new String(sb);
     }
@@ -324,54 +324,56 @@ public class XmlReader extends RubyObject {
     }
 
     private void readMoreData(ThreadContext context) {
-      if (!continueParsing) {
-        throw context.runtime.newRuntimeError("Cannot parse more data");
-      }
-      try {
-        continueParsing = config.parse(false);
-      } catch (XNIException e) {
-        Ruby ruby = context.runtime;
-        XmlSyntaxError exception = (XmlSyntaxError) NokogiriService.XML_SYNTAXERROR_ALLOCATOR.allocate(ruby, getNokogiriClass(ruby, "Nokogiri::XML::SyntaxError"));
-        throw new RaiseException(exception);
-      } catch (IOException e) {
-        throw context.getRuntime().newRuntimeError("Received IOException: " + e.getMessage());
-      }
+        if (!continueParsing) throw context.runtime.newRuntimeError("Cannot parse more data");
+        try {
+            continueParsing = config.parse(false);
+        }
+        catch (XNIException e) {
+            throw new RaiseException(XmlSyntaxError.createXMLSyntaxError(context.runtime, e)); // Nokogiri::XML::SyntaxError
+        }
+        catch (IOException e) {
+            throw context.runtime.newRuntimeError(e.toString());
+        }
     }
 
     private void ensureNodeClosed(ThreadContext context) {
-      ReaderNode node = currentNode();
-      if (node instanceof TextNode) {
-        return;
-      }
-      while (node.endOffset < 1) {
-        readMoreData(context);
-      }
+        ReaderNode node = currentNode();
+        if (node instanceof TextNode) return;
+        while (node.endOffset < 1) readMoreData(context);
     }
 
     @JRubyMethod
     public IRubyObject read(ThreadContext context) {
         position++;
-        while (nodeQueue.size() <= position && continueParsing) {
-          readMoreData(context);
+        try {
+            while (nodeQueue.size() <= position && continueParsing) {
+                readMoreData(context);
+            }
+            return setAndRaiseErrorsIfAny(context.runtime, null);
+        }
+        catch (RaiseException ex) {
+            return setAndRaiseErrorsIfAny(context.runtime, ex);
         }
-        if(currentNode() == null) {
-            return context.nil;
-        } else if(currentNode().isError()) {
-            RubyArray errors = (RubyArray) this.getInstanceVariable("@errors");
-            errors.append(currentNode().toSyntaxError());
+    }
 
-            this.setInstanceVariable("@errors", errors);
+    private IRubyObject setAndRaiseErrorsIfAny(final Ruby runtime, final RaiseException ex) throws RaiseException {
+        final ReaderNode currentNode = currentNode();
+        if (currentNode == null) return runtime.getNil();
+        if (currentNode.isError()) {
+            RubyArray errors = (RubyArray) getInstanceVariable("@errors");
+            IRubyObject error = currentNode.toSyntaxError();
+            errors.append(error);
+            setInstanceVariable("@errors", errors);
 
-            throw new RaiseException((XmlSyntaxError) currentNode().toSyntaxError());
-        } else {
-            return this;
+            throw ex != null ? ex : new RaiseException((XmlSyntaxError) error);
         }
+        if ( ex != null ) throw ex;
+        return this;
     }
 
     private ReaderNode currentNode() {
-      if (position >= nodeQueue.size())
-        return null;
-      return nodeQueue.get(position);
+        if (position >= nodeQueue.size()) return null;
+        return nodeQueue.get(position);
     }
 
     @JRubyMethod
@@ -420,15 +422,13 @@ public class XmlReader extends RubyObject {
           this.ruby = ruby;
         }
 
-
-
         @Override
-        public void startGeneralEntity(String name, XMLResourceIdentifier identifier, String encoding,
-            Augmentations augs) throws XNIException {
-          Object entitySkipped;
-          if (augs != null && (entitySkipped = augs.getItem(Constants.ENTITY_SKIPPED)) != null && ((Boolean) entitySkipped) == true) {
-            nodeQueue.add(new ReaderNode.ExceptionNode(ruby, null));
-          }
+        public void startGeneralEntity(String name, XMLResourceIdentifier identifier,
+                                       String encoding, Augmentations augs) throws XNIException {
+            Object entitySkipped;
+            if (augs != null && (entitySkipped = augs.getItem(Constants.ENTITY_SKIPPED)) != null && ((Boolean) entitySkipped)) {
+                nodeQueue.add(new ReaderNode.ExceptionNode(ruby, null));
+            }
         }
 
 
@@ -479,7 +479,7 @@ public class XmlReader extends RubyObject {
 
         @Override
         public void emptyElement(QName element, XMLAttributes attrs, Augmentations augs) {
-          commonElement(element, attrs, true);
+            commonElement(element, attrs, true);
         }
 
         private void commonElement(QName element, XMLAttributes attrs, boolean isEmpty) {
@@ -528,5 +528,5 @@ public class XmlReader extends RubyObject {
             nodeQueue.add(new ReaderNode.ExceptionNode(ruby, ex));
             throw ex;
         }
-    };
+    }
 }

data/ext/java/nokogiri/XmlRelaxng.java

@@ -93,7 +93,7 @@ public class XmlRelaxng extends XmlSchema {
     }
 
     private Schema getSchema(Source source, ThreadContext context) {
-        InputStream is = null;
+        InputStream is;
         VerifierFactory factory = new com.thaiopensource.relaxng.jarv.VerifierFactoryImpl();
         if (source instanceof StreamSource) {
             StreamSource ss = (StreamSource)source;

data/ext/java/nokogiri/XmlSaxPushParser.java

@@ -46,6 +46,7 @@ import java.util.concurrent.ThreadFactory;
 
 import nokogiri.internals.ClosedStreamException;
 import nokogiri.internals.NokogiriBlockingQueueInputStream;
+import nokogiri.internals.NokogiriHelpers;
 import nokogiri.internals.ParserContext;
 
 import org.jruby.Ruby;
@@ -58,6 +59,7 @@ import org.jruby.anno.JRubyMethod;
 import org.jruby.exceptions.RaiseException;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
 import org.xml.sax.SAXException;
 
 /**
@@ -115,42 +117,60 @@ public class XmlSaxPushParser extends RubyObject {
         return getOptions(context);
     }
 
+    /**
+     * Can take a boolean assignment.
+     *
+     * @param context
+     * @param value
+     * @return
+     */
+    @JRubyMethod(name = "replace_entities=")
+    public IRubyObject setReplaceEntities(ThreadContext context, IRubyObject value) {
+        // Ignore the value.
+        return this;
+    }
+
+    @JRubyMethod(name="replace_entities")
+    public IRubyObject getReplaceEntities(ThreadContext context) {
+        // The java parser always replaces entities.
+        return context.getRuntime().getTrue();
+    }
+
     @JRubyMethod
     public IRubyObject native_write(ThreadContext context, IRubyObject chunk,
                                     IRubyObject isLast) {
         try {
             initialize_task(context);
         } catch (IOException e) {
-            throw context.getRuntime().newRuntimeError(e.getMessage());
+            throw context.runtime.newRuntimeError(e.getMessage());
         }
-        byte[] data = null;
-        if (chunk instanceof RubyString || chunk.respondsTo("to_str")) {
-            data = chunk.convertToString().getBytes();
-        } else {
+        final ByteArrayInputStream data = NokogiriHelpers.stringBytesToStream(chunk);
+        if (data == null) {
             terminateTask(context);
-            XmlSyntaxError xmlSyntaxError =
-                (XmlSyntaxError) NokogiriService.XML_SYNTAXERROR_ALLOCATOR.allocate(context.getRuntime(), getNokogiriClass(context.getRuntime(), "Nokogiri::XML::SyntaxError"));
-            throw new RaiseException(xmlSyntaxError);
+            throw new RaiseException(XmlSyntaxError.createXMLSyntaxError(context.runtime)); // Nokogiri::XML::SyntaxError
         }
 
-        int errorCount0 = parserTask.getErrorCount();;
+        int errorCount0 = parserTask.getErrorCount();
 
 
         if (isLast.isTrue()) {
             try {
                 parserTask.parser.getNokogiriHandler().endDocument();
-            } catch (SAXException e) {
-                throw context.getRuntime().newRuntimeError(e.getMessage());
+            }
+            catch (SAXException e) {
+                throw context.runtime.newRuntimeError(e.getMessage());
             }
             terminateTask(context);
         } else {
             try {
-              Future<Void> task = stream.addChunk(new ByteArrayInputStream(data));
-              task.get();
-            } catch (ClosedStreamException ex) {
-              // this means the stream is closed, ignore this exception
-            } catch (Exception e) {
-              throw context.getRuntime().newRuntimeError(e.getMessage());
+                Future<Void> task = stream.addChunk(data);
+                task.get();
+            }
+            catch (ClosedStreamException ex) {
+                // this means the stream is closed, ignore this exception
+            }
+            catch (Exception e) {
+                throw context.runtime.newRuntimeError(e.toString());
             }
 
         }