nokogiri 1.5.5.rc3-java → 1.5.6-java

data/ext/java/nokogiri/XmlSaxPushParser.java

@@ -35,16 +35,16 @@ package nokogiri;
 import static nokogiri.internals.NokogiriHelpers.getNokogiriClass;
 import static org.jruby.javasupport.util.RuntimeHelpers.invoke;
 
+import java.io.ByteArrayInputStream;
 import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.nio.channels.Channels;
-import java.nio.channels.Pipe;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
 import java.util.concurrent.FutureTask;
 
+import nokogiri.internals.ClosedStreamException;
+import nokogiri.internals.NokogiriBlockingQueueInputStream;
 import nokogiri.internals.ParserContext;
 
 import org.jruby.Ruby;
@@ -69,8 +69,7 @@ public class XmlSaxPushParser extends RubyObject {
     ParserContext.Options options;
     IRubyObject optionsRuby;
     IRubyObject saxParser;
-    OutputStream ostream = null;
-    InputStream istream = null;
+    NokogiriBlockingQueueInputStream stream;
     ParserTask parserTask = null;
     FutureTask<XmlSaxParserContext> futureTask = null;
     ExecutorService executor = null;
@@ -120,53 +119,43 @@ public class XmlSaxPushParser extends RubyObject {
         byte[] data = null;
         if (chunk instanceof RubyString || chunk.respondsTo("to_str")) {
             data = chunk.convertToString().getBytes();
-        } else { 
-            try {
-                terminateTask();
-            } catch (IOException e) {
-                throw context.getRuntime().newRuntimeError(e.getMessage());
-            }
-            XmlSyntaxError xmlSyntaxError = 
+        } else {
+            terminateTask(context);
+            XmlSyntaxError xmlSyntaxError =
                 (XmlSyntaxError) NokogiriService.XML_SYNTAXERROR_ALLOCATOR.allocate(context.getRuntime(), getNokogiriClass(context.getRuntime(), "Nokogiri::XML::SyntaxError"));
             throw new RaiseException(xmlSyntaxError);
         }
 
         int errorCount0 = parserTask.getErrorCount();;
-        
-        try {
-            if (isLast.isTrue()) {
-                IRubyObject document = invoke(context, this, "document");
-                invoke(context, document, "end_document");
-                terminateTask();
-            } else {
-                ostream.write(data);
-                Thread.currentThread().sleep(10);   // gives a reader a chance to work
+
+
+        if (isLast.isTrue()) {
+            IRubyObject document = invoke(context, this, "document");
+            invoke(context, document, "end_document");
+            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());
             }
-        } catch (IOException e) {
-            throw context.getRuntime().newRuntimeError(e.getMessage());
-        } catch (InterruptedException e) {
-            throw context.getRuntime().newRuntimeError(e.getMessage());
+
         }
 
         if (!options.recover && parserTask.getErrorCount() > errorCount0) {
-            try {
-                terminateTask();
-            } catch (IOException e) {
-                throw context.getRuntime().newRuntimeError(e.getMessage());
-            }
+            terminateTask(context);
             throw new RaiseException(parserTask.getLastError(), true);
         }
 
         return this;
     }
-    
+
     private void initialize_task(ThreadContext context) throws IOException {
-        if (futureTask == null || ostream == null || istream == null) {
-            Pipe pipe = Pipe.open();
-            Pipe.SinkChannel sink = pipe.sink();
-            ostream = Channels.newOutputStream(sink);
-            Pipe.SourceChannel source = pipe.source();
-            istream = Channels.newInputStream(source);
+        if (futureTask == null || stream == null) {
+            stream = new NokogiriBlockingQueueInputStream();
 
             parserTask = new ParserTask(context, saxParser);
             futureTask = new FutureTask<XmlSaxParserContext>(parserTask);
@@ -174,40 +163,53 @@ public class XmlSaxPushParser extends RubyObject {
             executor.submit(futureTask);
         }
     }
-    
-    private synchronized void terminateTask() throws IOException {
+
+    private synchronized void terminateTask(ThreadContext context) {
+        try {
+          Future<Void> task = stream.addChunk(NokogiriBlockingQueueInputStream.END);
+          task.get();
+        } catch (ClosedStreamException ex) {
+          // ignore this exception, it means the stream was closed
+        } catch (Exception e) {
+            throw context.getRuntime().newRuntimeError(e.getMessage());
+        }
         futureTask.cancel(true);
         executor.shutdown();
-        ostream.close();
-        istream.close();
-        ostream = null;
-        istream = null;
+        executor = null;
+        stream = null;
+        futureTask = null;
     }
-    
+
     private class ParserTask implements Callable<XmlSaxParserContext> {
-        private ThreadContext context;
-        private IRubyObject handler;
-        private XmlSaxParserContext parser;
-        
+        private final ThreadContext context;
+        private final IRubyObject handler;
+        private final XmlSaxParserContext parser;
+
         private ParserTask(ThreadContext context, IRubyObject handler) {
             RubyClass klazz = getNokogiriClass(context.getRuntime(), "Nokogiri::XML::SAX::ParserContext");
             this.context = context;
             this.handler = handler;
-            this.parser = (XmlSaxParserContext) XmlSaxParserContext.parse_stream(context, klazz, istream);
+            this.parser = (XmlSaxParserContext) XmlSaxParserContext.parse_stream(context, klazz, stream);
         }
 
         @Override
         public XmlSaxParserContext call() throws Exception {
+          try {
             parser.parse_with(context, handler);
-            return parser;
+          } finally {
+            // we have to close the stream before exiting, otherwise someone
+            // can add a chunk and block on task.get() forever.
+            stream.close();
+          }
+          return parser;
         }
-        
+
         private synchronized int getErrorCount() {
             // check for null because thread may not have started yet
             if (parser.getNokogiriHandler() == null) return 0;
             else return parser.getNokogiriHandler().getErrorCount();
         }
-        
+
         private synchronized RubyException getLastError() {
             return (RubyException) parser.getNokogiriHandler().getLastError();
         }

data/ext/java/nokogiri/XmlText.java

@@ -34,13 +34,11 @@ package nokogiri;
 
 import static nokogiri.internals.NokogiriHelpers.getCachedNodeOrCreate;
 import static nokogiri.internals.NokogiriHelpers.rubyStringToString;
-import static nokogiri.internals.NokogiriHelpers.stringOrNil;
 import nokogiri.internals.SaveContextVisitor;
 
 import org.jruby.Ruby;
 import org.jruby.RubyClass;
 import org.jruby.anno.JRubyClass;
-import org.jruby.anno.JRubyMethod;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.w3c.dom.Document;
@@ -88,17 +86,7 @@ public class XmlText extends XmlNode {
         if (name == null) name = context.getRuntime().newString("text");
         return name;
     }
-    
-    @Override
-    @JRubyMethod(name = {"content", "text", "inner_text"})
-    public IRubyObject content(ThreadContext context) {
-        if (content == null || content.isNil()) {
-            return stringOrNil(context.getRuntime(), node.getTextContent());
-        } else {
-            return content;
-        }
-    }
-    
+
     @Override
     public void accept(ThreadContext context, SaveContextVisitor visitor) {
         visitor.enter((Text)node);
@@ -114,6 +102,6 @@ public class XmlText extends XmlNode {
             }
             child = child.getNextSibling();
         }
-        visitor.leave((Text)node);
+        visitor.leave(node);
     }
 }

data/ext/java/nokogiri/XsltStylesheet.java

@@ -163,7 +163,7 @@ public class XsltStylesheet extends RubyObject {
         try {
             xslt.init(args[1], doc);
         } catch (TransformerConfigurationException ex) {
-            runtime.newRuntimeError("could not parse xslt stylesheet");
+            throw runtime.newRuntimeError("could not parse xslt stylesheet");
         }
 
         return xslt;
@@ -172,6 +172,8 @@ public class XsltStylesheet extends RubyObject {
     private void init(IRubyObject stylesheet, Document document) throws TransformerConfigurationException {
         this.stylesheet = stylesheet;  // either RubyString or RubyFile
         if (factory == null) factory = TransformerFactory.newInstance();
+        NokogiriXsltErrorListener elistener = new NokogiriXsltErrorListener();
+        factory.setErrorListener(elistener);
         sheet = factory.newTemplates(new DOMSource(document));
     }
     
@@ -187,7 +189,7 @@ public class XsltStylesheet extends RubyObject {
         Ruby runtime = context.getRuntime();
         RubyArray errors_of_xmlDoc = (RubyArray) xmlDoc.getInstanceVariable("@errors");
         if (!errors_of_xmlDoc.isEmpty()) {
-            throw runtime.newRuntimeError(errors_of_xmlDoc.first().asJavaString());
+            throw runtime.newRuntimeError(errors_of_xmlDoc.first().asString().asJavaString());
         }
     }
 

data/ext/java/nokogiri/internals/ClosedStreamException.java

@@ -0,0 +1,10 @@
+package nokogiri.internals;
+
+@SuppressWarnings("serial")
+public class ClosedStreamException extends Exception {
+
+  public ClosedStreamException(String message) {
+    super(message);
+  }
+
+}

data/ext/java/nokogiri/internals/HtmlDomParserContext.java

@@ -91,7 +91,8 @@ public class HtmlDomParserContext extends XmlDomParserContext {
         XMLDocumentFilter[] filters = { elementValidityCheckFilter};
 
         config.setErrorHandler(this.errorHandler);
-        parser = new DOMParser(config);
+
+        parser = new NokogiriDomParser(config);
 
         // see http://nekohtml.sourceforge.net/settings.html for details
         setProperty("http://cyberneko.org/html/properties/default-encoding", java_encoding);
@@ -100,7 +101,6 @@ public class HtmlDomParserContext extends XmlDomParserContext {
         setProperty("http://cyberneko.org/html/properties/filters", filters);
         setFeature("http://cyberneko.org/html/features/report-errors", true);
         setFeature("http://xml.org/sax/features/namespaces", false);
-        setFeature("http://cyberneko.org/html/features/insert-doctype", true);
     }
 
     /**

data/ext/java/nokogiri/internals/NokogiriBlockingQueueInputStream.java

@@ -0,0 +1,151 @@
+/**
+ *
+ */
+package nokogiri.internals;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Future;
+import java.util.concurrent.FutureTask;
+import java.util.concurrent.LinkedBlockingQueue;
+
+import nokogiri.XmlSaxPushParser;
+
+/**
+ * A smart input stream that signals the caller when a chunk of data is consumed
+ * from the stream. The main use of this stream is to synchronize the
+ * {@link XmlSaxPushParser} and the {@link XmlSaxParser} which runs in a
+ * different thread.
+ *
+ * @author John Shahid <jvshahid@gmail.com>
+ */
+public class NokogiriBlockingQueueInputStream extends InputStream {
+  private final LinkedBlockingQueue<Task>  queue;
+  protected Task                           currentTask;
+  protected ByteArrayInputStream           currentStream;
+  protected int                            position;
+  protected boolean                        closed = false;
+
+  public static final ByteArrayInputStream END    = new ByteArrayInputStream(new byte[0]);
+
+  private static class Task extends FutureTask<Void> {
+    private final ByteArrayInputStream stream;
+
+    public Task(ByteArrayInputStream stream) {
+      super(new Callable<Void>() {
+        @Override
+        public Void call() throws Exception {
+          // TODO Auto-generated method stub
+          return null;
+        }
+      });
+      this.stream = stream;
+    }
+
+    public ByteArrayInputStream getStream() {
+      return stream;
+    }
+
+    @Override
+    public void run() {
+      // don't do anything
+    }
+
+    @Override
+    public boolean runAndReset() {
+      // don't do anything
+      return true;
+    }
+
+    @Override
+    public void set(Void v) {
+      super.set(v);
+    }
+  }
+
+  public NokogiriBlockingQueueInputStream() {
+    queue = new LinkedBlockingQueue<Task>();
+  }
+
+  /**
+   * This method shouldn't be called unless the parser has finished parsing or
+   * threw an exception while doing so, otherwise, there'll be the protential
+   * that the read method will block indefinitely.
+   */
+  @Override
+  public synchronized void close() {
+    closed = true;
+    List<Task> tasks = new LinkedList<Task>();
+    queue.drainTo(tasks);
+    tasks.add(currentTask);
+    for (Task task : tasks) {
+      task.set(null);
+    }
+  }
+
+  /**
+   * Add @param stream to the end of the queue of data that will be returned by
+   * {@link #read()} and its variants. The method will @return a future whose
+   * {@link Future#get()} will block until the data in @param stream is read.
+   *
+   * Passing the special stream {@link #END} to this method, will cause
+   * {@link #read()} to return an eof indicator (i.e. -1) to the caller, after
+   * all the data inserted before {@link #END} is processed.
+   *
+   * @return
+   */
+  public synchronized Future<Void> addChunk(ByteArrayInputStream stream) throws ClosedStreamException {
+    if (closed)
+      throw new ClosedStreamException("Cannot add a chunk to a closed stream");
+    Task task = new Task(stream);
+    queue.add(task);
+    return task;
+  }
+
+  /*
+   * (non-Javadoc)
+   *
+   * @see java.io.InputStream#read()
+   */
+  @Override
+  public int read() throws IOException {
+    if (currentTask == null || currentStream.available() == 0)
+      if (getNextTask() == -1)
+        return -1;
+    return currentStream.read();
+  }
+
+  /*
+   * (non-Javadoc)
+   *
+   * @see java.io.InputStream#read(byte[], int, int)
+   */
+  @Override
+  public int read(byte[] bytes, int off, int len) {
+    if (currentTask == null || currentStream.available() == 0) {
+      if (getNextTask() == -1) {
+        currentTask.set(null);
+        return -1;
+      }
+    }
+    return currentStream.read(bytes, off, len);
+  }
+
+  protected int getNextTask() {
+    while (true) {
+      try {
+        if (currentTask != null)
+          currentTask.set(null);
+        currentTask = queue.take();
+        currentStream = currentTask.getStream();
+        return currentStream.available() == 0 ? -1 : currentStream.available();
+      } catch (InterruptedException ex) {
+        // keep retrying to read
+      }
+    }
+  }
+}

data/ext/java/nokogiri/internals/{XmlDomParser.java → NokogiriDomParser.java}

@@ -53,23 +53,34 @@ import org.xml.sax.SAXException;
  *
  * @author Patrick Mahoney <pat@polycrystal.org>
  */
-public class XmlDomParser extends DOMParser {
-    DOMParser dtd;
-    ParserContext.Options options;
+public class NokogiriDomParser extends DOMParser {
+    protected DOMParser dtd;
+    protected boolean xInclude;
+    protected XMLParserConfiguration config;
 
-    public XmlDomParser(ParserContext.Options options) {
-        super();
-        this.options = options;
+    public NokogiriDomParser(XMLParserConfiguration config) {
+        super(config);
+        this.config = config;
+        initialize();
+    }
+
+    public NokogiriDomParser(ParserContext.Options options) {
+        xInclude = options.xInclude;
+        initialize();
+    }
+
+    protected void initialize() {
+        if (config == null) {
+            if (xInclude) {
+                config = new XIncludeParserConfiguration();
+            } else {
+                config = getXMLParserConfiguration();
+            }
+        }
 
         DTDConfiguration dtdConfig = new DTDConfiguration();
         dtd = new DOMParser(dtdConfig);
 
-        XMLParserConfiguration config;
-        if (options.xInclude) {
-            config = new XIncludeParserConfiguration();
-        } else {
-            config = getXMLParserConfiguration();
-        }
         config.setDTDHandler(dtdConfig);
         config.setDTDContentModelHandler(dtdConfig);
     }
@@ -77,7 +88,7 @@ public class XmlDomParser extends DOMParser {
     @Override
     public void parse(InputSource source) throws SAXException, IOException {
         dtd.reset();
-        if (options.xInclude) {
+        if (xInclude) {
             setEntityResolver(new NokogiriXInlcudeEntityResolver(source));
         }
         super.parse(source);
@@ -87,7 +98,7 @@ public class XmlDomParser extends DOMParser {
 
         doc.setUserData(XmlDocument.DTD_RAW_DOCUMENT, dtd.getDocument(), null);
     }
-    
+
     private class NokogiriXInlcudeEntityResolver implements org.xml.sax.EntityResolver {
         InputSource source;
         private NokogiriXInlcudeEntityResolver(InputSource source) {