nokogiri 1.5.6.rc1-java → 1.5.6.rc2-java

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) {

data/ext/java/nokogiri/internals/NokogiriEncodingReaderWrapper.java

@@ -0,0 +1,109 @@
+package nokogiri.internals;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+import org.jruby.Ruby;
+import org.jruby.RubyObject;
+import org.jruby.RubyProcess.Sys;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.javasupport.util.RuntimeHelpers;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
+
+/**
+ * This class wraps the EncodingReader which act like a rewinding input stream,
+ * it tries to read the first 1K of data to detect the encoding, but save
+ * this data in a buffer for the subsequent read. Unfortunately, the EncodingReader
+ * will behave as expected only if encoding was detected, otherwise, the read data
+ * won't be stored and EncodingReader will fallback to read directory from the io stream.
+ * this is kind of lame, since we need to have similar logic in both layers. The alternative
+ * is to implement the encoding detection similar to the way C-Nokogiri does it; it starts
+ * parsing assuming encoding is unknown and if encoding is detected it will throw an exception
+ * causing parsing to stop, in which case we have to intercept the exception and set the encoding.
+ * Also in this case we don't have to restart the parsing since html/document.rb does that for us.
+ *
+ * @author John Shahid <jvshahid@gmail.com>
+ *
+ */
+public class NokogiriEncodingReaderWrapper extends InputStream {
+  private final ThreadContext context;
+  private final IRubyObject   encodingReader;
+  private final Ruby          ruby;
+  private IRubyObject         detectedEncoding;
+  private final byte[]        firstChunk       = new byte[1024];
+  private int                 firstChunkOff    = 0;
+  private int                 firstChunkLength = 0;
+
+  public NokogiriEncodingReaderWrapper(ThreadContext context, RubyObject encodingReader) {
+    this.context = context;
+    this.encodingReader = encodingReader;
+    this.ruby = context.getRuntime();
+
+    if (!RuntimeHelpers.invoke(context, encodingReader, "respond_to?", ruby.newSymbol("read").to_sym()).isTrue()
+        || encodingReader.getInstanceVariable("@io") == null) {
+      throw ruby.newArgumentError("Argument doesn't respond to read or doesn't have instance variable @io");
+    }
+  }
+
+  public boolean detectEncoding() {
+    try {
+      firstChunkLength = read(firstChunk);
+    } catch (RaiseException e) {
+      detectedEncoding = e.getException().getInstanceVariable("@found_encoding");
+      return true;
+    }
+    detectedEncoding = context.nil;
+    return false;
+  }
+
+  public IRubyObject getEncoding() {
+    return detectedEncoding;
+  }
+
+  @Override
+  public int read(byte b[]) {
+    return read(b, 0, b.length);
+  }
+
+  @Override
+  public int read(byte b[], int off, int len) {
+    if (b == null) {
+      throw new NullPointerException();
+    } else if (off < 0 || len < 0 || len > b.length - off) {
+      throw new IndexOutOfBoundsException();
+    } else if (len == 0) {
+      return 0;
+    }
+
+    int copyLength = Math.min(firstChunkLength - firstChunkOff, len);
+    if (copyLength > 0) {
+      System.arraycopy(firstChunk, firstChunkOff, b, off, copyLength);
+      len -= copyLength;
+      firstChunkOff += copyLength;
+    }
+
+    if (len <= 0)
+      return copyLength;
+
+    IRubyObject returnValue = encodingReader.callMethod(context, "read", ruby.newFixnum(len));
+    if (returnValue.isNil())
+      return -1;
+
+    ByteList bytes = returnValue.asString().getByteList();
+    int length = bytes.length();
+    System.arraycopy(bytes.unsafeBytes(), bytes.getBegin(), b, off + copyLength, length);
+    return length + copyLength;
+  }
+
+  @Override
+  public int read() {
+    byte[] bytes = new byte[1];
+    int count = read(bytes, 0, 1);
+    if (count < 1)
+      return count;
+    return bytes[0];
+  }
+
+}

data/ext/java/nokogiri/internals/NokogiriEntityResolver.java

@@ -0,0 +1,123 @@
+package nokogiri.internals;
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+
+import nokogiri.internals.ParserContext.Options;
+
+import org.jruby.Ruby;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+import org.xml.sax.ext.EntityResolver2;
+
+/**
+ * An entity resolver aware of the fact that the Ruby runtime can
+ * change directory but the JVM cannot.  Thus any file based
+ * entity resolution that uses relative paths must be translated
+ * to be relative to the current directory of the Ruby runtime.
+ */
+public class NokogiriEntityResolver implements EntityResolver2 {
+    protected Ruby runtime;
+    private final NokogiriErrorHandler handler;
+    private final Options options;
+
+    public NokogiriEntityResolver(Ruby runtime, NokogiriErrorHandler handler, Options options) {
+        super();
+        this.runtime = runtime;
+        this.handler = handler;
+        this.options = options;
+    }
+
+    @Override
+    public InputSource getExternalSubset(String name, String baseURI)
+        throws SAXException, IOException {
+      return null;
+    }
+
+    @Override
+    public InputSource resolveEntity(String publicId, String systemId)
+        throws SAXException, IOException {
+        return resolveEntity(runtime, null, publicId, null, systemId);
+    }
+
+    @Override
+    public InputSource resolveEntity(String name,
+                                     String publicId,
+                                     String baseURI,
+                                     String systemId)
+        throws SAXException, IOException {
+        return resolveEntity(runtime, name, publicId, baseURI, systemId);
+    }
+
+    private File join(String parent, String child) {
+      if (new File(parent).isFile()) {
+        parent = new File(parent).getParent();
+      }
+
+      return new File(parent, child);
+    }
+
+    private InputSource emptyInputSource(InputSource source) {
+      source.setByteStream(new ByteArrayInputStream(new byte[0]));
+      return source;
+    }
+
+    private boolean shouldLoadDtd() {
+      return options.dtdLoad || options.dtdValid;
+    }
+
+    private void addError(String errorMessage) {
+      if (handler != null)
+        handler.errors.add(new Exception(errorMessage));
+    }
+
+    /**
+     * Create a file base input source taking into account the current
+     * directory of <code>runtime</code>.
+     * @throws SAXException
+     */
+    protected InputSource resolveEntity(Ruby runtime, String name, String publicId, String baseURI, String systemId)
+        throws IOException, SAXException {
+        InputSource s = new InputSource();
+        if (name.equals("[dtd]") && !shouldLoadDtd()) {
+          return emptyInputSource(s);
+        } else if (!name.equals("[dtd]") && !options.noEnt) {
+          return emptyInputSource(s);
+        }
+        String adjustedSystemId;
+        URI uri = URI.create(systemId);
+        if (options.noNet && uri.getHost() != null) {
+          addError("Attempt to load network entity " + systemId);
+          return emptyInputSource(s);
+        }
+        // if this is a url or absolute file name then use it
+        if (uri.isAbsolute() && !uri.isOpaque()) {
+          adjustedSystemId = uri.toURL().toString();
+        } else if (new File(uri.getPath()).isAbsolute()) {
+          adjustedSystemId = uri.getPath();
+        } else if (baseURI != null) {
+          URI baseuri = URI.create(baseURI);
+          if (options.noNet && baseuri.getHost() != null) {
+            addError("Attempt to load network entity " + systemId);
+            return emptyInputSource(s);
+          }
+          if (baseuri.getHost() == null) {
+            // this is a local file
+            adjustedSystemId = join(baseuri.getPath(), uri.getPath()).getCanonicalPath();
+          } else {
+            // this is a url, then resolve uri using baseuri
+            adjustedSystemId = baseuri.resolve(systemId).toURL().toString();
+          }
+        } else {
+          // baseURI is null we have to use the current working directory to resolve the entity
+          String pwd = runtime.getCurrentDirectory();
+          adjustedSystemId = join(pwd, uri.getPath()).getCanonicalPath();
+        }
+        s.setSystemId(adjustedSystemId);
+        s.setPublicId(publicId);
+        return s;
+    }
+
+}