nokogiri 1.8.2-java → 1.8.3-java

data/ext/java/nokogiri/XmlSaxPushParser.java

@@ -37,29 +37,25 @@ import static org.jruby.javasupport.util.RuntimeHelpers.invoke;
 
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
-import java.util.concurrent.Callable;
+import java.io.InputStream;
+import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 import java.util.concurrent.FutureTask;
 import java.util.concurrent.ThreadFactory;
 
-import nokogiri.internals.ClosedStreamException;
-import nokogiri.internals.NokogiriBlockingQueueInputStream;
-import nokogiri.internals.NokogiriHelpers;
-import nokogiri.internals.ParserContext;
+import nokogiri.internals.*;
 
 import org.jruby.Ruby;
 import org.jruby.RubyClass;
 import org.jruby.RubyException;
 import org.jruby.RubyObject;
-import org.jruby.RubyString;
 import org.jruby.anno.JRubyClass;
 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;
 
 /**
@@ -71,12 +67,14 @@ import org.xml.sax.SAXException;
 @JRubyClass(name="Nokogiri::XML::SAX::PushParser")
 public class XmlSaxPushParser extends RubyObject {
     ParserContext.Options options;
-    IRubyObject optionsRuby;
     IRubyObject saxParser;
+
     NokogiriBlockingQueueInputStream stream;
-    ParserTask parserTask = null;
-    FutureTask<XmlSaxParserContext> futureTask = null;
-    ExecutorService executor = null;
+
+    private ParserTask parserTask = null;
+    private FutureTask<XmlSaxParserContext> futureTask = null;
+    private ExecutorService executor = null;
+    RaiseException ex = null;
 
     public XmlSaxPushParser(Ruby ruby, RubyClass rubyClass) {
         super(ruby, rubyClass);
@@ -84,36 +82,37 @@ public class XmlSaxPushParser extends RubyObject {
 
     @Override
     public void finalize() {
-      terminateTask(null);
+        try {
+            terminateImpl();
+        }
+        catch (Exception e) { /* ignored */ }
     }
 
     @JRubyMethod
-    public IRubyObject initialize_native(final ThreadContext context,
-                                         IRubyObject saxParser,
-                                         IRubyObject fileName) {
-        optionsRuby
-            = invoke(context, context.getRuntime().getClassFromPath("Nokogiri::XML::ParseOptions"), "new");
+    public IRubyObject initialize_native(final ThreadContext context, IRubyObject saxParser, IRubyObject fileName) {
         options = new ParserContext.Options(0);
         this.saxParser = saxParser;
         return this;
     }
 
-    /**
-     * Returns an integer.
-     */
+    private transient IRubyObject parse_options;
+
+    private IRubyObject parse_options(final ThreadContext context) {
+        if (parse_options == null) {
+            parse_options = invoke(context, context.runtime.getClassFromPath("Nokogiri::XML::ParseOptions"), "new");
+        }
+        return parse_options;
+    }
+
     @JRubyMethod(name="options")
     public IRubyObject getOptions(ThreadContext context) {
-        return invoke(context, optionsRuby, "options");
+        return invoke(context, parse_options(context), "options");
     }
 
-    /**
-     * <code>val</code> is an integer.
-     */
     @JRubyMethod(name="options=")
-    public IRubyObject setOptions(ThreadContext context, IRubyObject val) {
-        invoke(context, optionsRuby, "options=", val);
-        options =
-            new ParserContext.Options(val.convertToInteger().getLongValue());
+    public IRubyObject setOptions(ThreadContext context, IRubyObject opts) {
+        invoke(context, parse_options(context), "options=", opts);
+        options = new ParserContext.Options(opts.convertToInteger().getLongValue());
         return getOptions(context);
     }
 
@@ -139,6 +138,11 @@ public class XmlSaxPushParser extends RubyObject {
     @JRubyMethod
     public IRubyObject native_write(ThreadContext context, IRubyObject chunk,
                                     IRubyObject isLast) {
+        if (ex != null) {
+            // parser has already errored, rethrow the exception
+            throw ex;
+        }
+
         try {
             initialize_task(context);
         } catch (IOException e) {
@@ -146,38 +150,28 @@ public class XmlSaxPushParser extends RubyObject {
         }
         final ByteArrayInputStream data = NokogiriHelpers.stringBytesToStream(chunk);
         if (data == null) {
-            terminateTask(context);
-            throw new RaiseException(XmlSyntaxError.createXMLSyntaxError(context.runtime)); // Nokogiri::XML::SyntaxError
+            return this;
         }
 
         int errorCount0 = parserTask.getErrorCount();
 
+        try {
+            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());
+        }
 
         if (isLast.isTrue()) {
-            try {
-                parserTask.parser.getNokogiriHandler().endDocument();
-            }
-            catch (SAXException e) {
-                throw context.runtime.newRuntimeError(e.getMessage());
-            }
-            terminateTask(context);
-        } else {
-            try {
-                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());
-            }
-
+            parserTask.getNokogiriHandler().endDocument();
+            terminateTask(context.runtime);
         }
 
         if (!options.recover && parserTask.getErrorCount() > errorCount0) {
-            terminateTask(context);
-            throw new RaiseException(parserTask.getLastError(), true);
+            terminateTask(context.runtime);
+            throw ex = parserTask.getLastError();
         }
 
         return this;
@@ -187,70 +181,104 @@ public class XmlSaxPushParser extends RubyObject {
         if (futureTask == null || stream == null) {
             stream = new NokogiriBlockingQueueInputStream();
 
-            parserTask = new ParserTask(context, saxParser);
+            assert saxParser != null : "saxParser null";
+            parserTask = new ParserTask(context, saxParser, stream);
             futureTask = new FutureTask<XmlSaxParserContext>(parserTask);
             executor = Executors.newSingleThreadExecutor(new ThreadFactory() {
-              @Override
-              public Thread newThread(Runnable r) {
-                Thread t = new Thread(r);
-                t.setName("XmlSaxPushParser");
-                t.setDaemon(true);
-                return t;
-              }
+                @Override
+                public Thread newThread(Runnable r) {
+                    Thread t = new Thread(r);
+                    t.setName("XmlSaxPushParser");
+                    t.setDaemon(true);
+                    return t;
+                }
             });
             executor.submit(futureTask);
         }
     }
 
-    private synchronized void terminateTask(ThreadContext context) {
+    private void terminateTask(final Ruby runtime) {
+        if (executor == null) return;
+
         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) {
-            if (context != null)
-              throw context.getRuntime().newRuntimeError(e.getMessage());
+            terminateImpl();
+        }
+        catch (InterruptedException e) {
+            throw runtime.newRuntimeError(e.toString());
+        }
+        catch (Exception e) {
+            throw runtime.newRuntimeError(e.toString());
+        }
+    }
+
+    private synchronized void terminateImpl() throws InterruptedException, ExecutionException {
+        terminateExecution(executor, stream, futureTask);
+
+        executor = null; stream = null; futureTask = null;
+    }
+
+    // SHARED for HtmlSaxPushParser
+    static void terminateExecution(final ExecutorService executor, final NokogiriBlockingQueueInputStream stream,
+                                   final FutureTask<?> futureTask)
+        throws InterruptedException, ExecutionException {
+
+        if (executor == null) return;
+
+        try {
+            Future<Void> task = stream.addChunk(NokogiriBlockingQueueInputStream.END);
+            task.get();
+        }
+        catch (ClosedStreamException ex) {
+            // ignore this exception, it means the stream was closed
         }
         futureTask.cancel(true);
         executor.shutdown();
-        executor = null;
-        stream = null;
-        futureTask = null;
     }
 
-    private class ParserTask implements Callable<XmlSaxParserContext> {
-        private final ThreadContext context;
-        private final IRubyObject handler;
-        private final XmlSaxParserContext parser;
+    private static XmlSaxParserContext parse(final Ruby runtime, final InputStream stream) {
+        RubyClass klazz = getNokogiriClass(runtime, "Nokogiri::XML::SAX::ParserContext");
+        return XmlSaxParserContext.parse_stream(runtime, klazz, stream);
+    }
+
+    static class ParserTask extends ParserContext.ParserTask<XmlSaxParserContext> {
+
+        final InputStream stream;
+
+        private ParserTask(ThreadContext context, IRubyObject handler, InputStream stream) {
+            this(context, handler, parse(context.runtime, stream), stream);
+        }
 
-        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, stream);
+        // IMPL with HtmlSaxPushParser
+        protected ParserTask(ThreadContext context, IRubyObject handler, XmlSaxParserContext parser, InputStream stream) {
+            super(context, handler, parser);
+            this.stream = stream;
         }
 
         @Override
         public XmlSaxParserContext call() throws Exception {
-          try {
-            parser.parse_with(context, handler);
-          } finally {
+            try {
+                parser.parse_with(context, handler);
+            }
+            finally { stream.close(); }
             // we have to close the stream before exiting, otherwise someone
             // can add a chunk and block on task.get() forever.
-            stream.close();
-          }
-          return parser;
+            return parser;
+        }
+
+        final NokogiriHandler getNokogiriHandler() {
+            return parser.getNokogiriHandler();
         }
 
-        private synchronized int getErrorCount() {
+        synchronized final int getErrorCount() {
             // check for null because thread may not have started yet
             if (parser.getNokogiriHandler() == null) return 0;
-            else return parser.getNokogiriHandler().getErrorCount();
+            return parser.getNokogiriHandler().getErrorCount();
         }
 
-        private synchronized RubyException getLastError() {
-            return (RubyException) parser.getNokogiriHandler().getLastError();
+        synchronized final RaiseException getLastError() {
+            return parser.getNokogiriHandler().getLastError();
         }
+
     }
+
 }

data/ext/java/nokogiri/XmlSyntaxError.java

@@ -34,10 +34,10 @@ package nokogiri;
 
 import static nokogiri.internals.NokogiriHelpers.stringOrNil;
 
-import org.jruby.CompatVersion;
 import org.jruby.Ruby;
 import org.jruby.RubyClass;
 import org.jruby.RubyException;
+import org.jruby.RubyString;
 import org.jruby.anno.JRubyClass;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.runtime.ThreadContext;
@@ -120,26 +120,18 @@ public class XmlSyntaxError extends RubyException {
         setInstanceVariable("@file", stringOrNil(runtime, exception.getSystemId()));
     }
 
-    //@Override
-    //"to_s" method was branched in 1.8 and 1.9 since JRuby 1.6.6
-    // to support older version of JRuby, the annotation is commented out
+    // NOTE: special care - due JRuby 1.7.x
+    
     @Override
-    @JRubyMethod(name = "to_s", compat = CompatVersion.RUBY1_8)
-    public IRubyObject to_s(ThreadContext context) {
-        IRubyObject msg = msg(context.runtime);
-        return msg != null ? msg : super.to_s(context);
-    }
+    public IRubyObject to_s(ThreadContext context) { return to_s19(context); }
 
-    //@Override
-    //"to_s" method was branched in 1.8 and 1.9 since JRuby 1.6.6
-    // to support older version of JRuby, the annotation is commented out
-    @JRubyMethod(name = "to_s", compat = CompatVersion.RUBY1_9)
-    public IRubyObject to_s19(ThreadContext context) {
-        IRubyObject msg = msg(context.runtime);
-        return msg != null ? msg : super.to_s19(context);
+    @JRubyMethod(name = "to_s")
+    public RubyString to_s19(ThreadContext context) {
+        RubyString msg = msg(context.runtime);
+        return msg != null ? msg : super.to_s(context).asString();
     }
 
-    private IRubyObject msg(final Ruby runtime) {
+    private RubyString msg(final Ruby runtime) {
         if (exception != null && exception.getMessage() != null) {
             if (messageSet) return null;
             return runtime.newString( exception.getMessage() );

data/ext/java/nokogiri/internals/NokogiriHandler.java

@@ -37,7 +37,10 @@ import static nokogiri.internals.NokogiriHelpers.getPrefix;
 import static nokogiri.internals.NokogiriHelpers.isNamespace;
 import static nokogiri.internals.NokogiriHelpers.stringOrNil;
 
+import java.util.Arrays;
+import java.util.HashSet;
 import java.util.LinkedList;
+import java.util.Set;
 
 import nokogiri.XmlSyntaxError;
 
@@ -45,6 +48,7 @@ import org.jruby.Ruby;
 import org.jruby.RubyArray;
 import org.jruby.RubyClass;
 import org.jruby.RubyObject;
+import org.jruby.exceptions.RaiseException;
 import org.jruby.javasupport.util.RuntimeHelpers;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
@@ -61,8 +65,9 @@ import org.xml.sax.ext.DefaultHandler2;
  * @author Yoko Harada <yokolet@gmail.com>
  */
 public class NokogiriHandler extends DefaultHandler2 implements XmlDeclHandler {
+
     StringBuilder charactersBuilder;
-    private final Ruby ruby;
+    private final Ruby runtime;
     private final RubyClass attrClass;
     private final IRubyObject object;
 
@@ -72,23 +77,24 @@ public class NokogiriHandler extends DefaultHandler2 implements XmlDeclHandler {
      * TODO: should these be stored in the document 'errors' array?
      * Currently only string messages are stored there.
      */
-    private final LinkedList<XmlSyntaxError> errors = new LinkedList<XmlSyntaxError>();
+    private final LinkedList<RaiseException> errors = new LinkedList<RaiseException>();
 
     private Locator locator;
-    private static String htmlParserName = "Nokogiri::HTML::SAX::Parser";
-    private boolean needEmptyAttrCheck = false;
+    private boolean needEmptyAttrCheck;
 
     public NokogiriHandler(Ruby runtime, IRubyObject object) {
-        this.ruby = runtime;
+        assert object != null;
+        this.runtime = runtime;
         this.attrClass = (RubyClass) runtime.getClassFromPath("Nokogiri::XML::SAX::Parser::Attribute");
         this.object = object;
+        charactersBuilder = new StringBuilder();
         String objectName = object.getMetaClass().getName();
-        if (htmlParserName.equals(objectName)) needEmptyAttrCheck = true;
+        if ("Nokogiri::HTML::SAX::Parser".equals(objectName)) needEmptyAttrCheck = true;
     }
 
     @Override
     public void skippedEntity(String skippedEntity) {
-        call("error", ruby.newString("Entity '" + skippedEntity + "' not defined\n"));
+        call("error", runtime.newString("Entity '" + skippedEntity + "' not defined\n"));
     }
 
     @Override
@@ -97,27 +103,24 @@ public class NokogiriHandler extends DefaultHandler2 implements XmlDeclHandler {
     }
 
     @Override
-    public void startDocument() throws SAXException {
+    public void startDocument() {
         call("start_document");
-        charactersBuilder = new StringBuilder();
     }
 
     @Override
     public void xmlDecl(String version, String encoding, String standalone) {
-        call("xmldecl", stringOrNil(ruby, version),
-             stringOrNil(ruby, encoding),
-             stringOrNil(ruby, standalone));
+        call("xmldecl", stringOrNil(runtime, version), stringOrNil(runtime, encoding), stringOrNil(runtime, standalone));
     }
 
     @Override
-    public void endDocument() throws SAXException {
+    public void endDocument() {
         populateCharacters();
         call("end_document");
     }
 
     @Override
     public void processingInstruction(String target, String data) {
-      call("processing_instruction", ruby.newString(target), ruby.newString(data));
+        call("processing_instruction", runtime.newString(target), runtime.newString(data));
     }
 
     /*
@@ -129,12 +132,14 @@ public class NokogiriHandler extends DefaultHandler2 implements XmlDeclHandler {
      */
     @Override
     public void startElement(String uri, String localName, String qName, Attributes attrs) throws SAXException {
+        final Ruby runtime = this.runtime;
+        final ThreadContext context = runtime.getCurrentContext();
+
         // for attributes other than namespace attrs
-        RubyArray rubyAttr = RubyArray.newArray(ruby);
+        RubyArray rubyAttr = RubyArray.newArray(runtime);
         // for namespace defining attributes
-        RubyArray rubyNSAttr = RubyArray.newArray(ruby);
+        RubyArray rubyNSAttr = RubyArray.newArray(runtime);
 
-        ThreadContext context = ruby.getCurrentContext();
         boolean fromFragmentHandler = false; // isFromFragmentHandler();
 
         for (int i = 0; i < attrs.getLength(); i++) {
@@ -145,134 +150,132 @@ public class NokogiriHandler extends DefaultHandler2 implements XmlDeclHandler {
             String pre;
 
             pre = getPrefix(qn);
-            if (ln == null || ln.equals("")) ln = getLocalPart(qn);
+            if (ln == null || ln.isEmpty()) ln = getLocalPart(qn);
 
             if (isNamespace(qn) && !fromFragmentHandler) {
                 // I haven't figured the reason out yet, but, in somewhere,
                 // namespace is converted to array in array and cause
                 // TypeError at line 45 in fragment_handler.rb
-                RubyArray ns = RubyArray.newArray(ruby, 2);
                 if (ln.equals("xmlns")) ln = null;
-                ns.add(stringOrNil(ruby, ln));
-                ns.add(ruby.newString(val));
-                rubyNSAttr.add(ns);
+                rubyNSAttr.append( runtime.newArray( stringOrNil(runtime, ln), runtime.newString(val) ) );
             } else {
                 IRubyObject[] args = null;
                 if (needEmptyAttrCheck) {
                     if (isEmptyAttr(ln)) {
-                        args = new IRubyObject[3];
-                        args[0] = stringOrNil(ruby, ln);
-                        args[1] = stringOrNil(ruby, pre);
-                        args[2] = stringOrNil(ruby, u);
+                        args = new IRubyObject[] {
+                            stringOrNil(runtime, ln),
+                            stringOrNil(runtime, pre),
+                            stringOrNil(runtime, u)
+                        };
                     }
                 }
                 if (args == null) {
-                    args = new IRubyObject[4];
-                    args[0] = stringOrNil(ruby, ln);
-                    args[1] = stringOrNil(ruby, pre);
-                    args[2] = stringOrNil(ruby, u);
-                    args[3] = stringOrNil(ruby, val);
+                    args = new IRubyObject[] {
+                        stringOrNil(runtime, ln),
+                        stringOrNil(runtime, pre),
+                        stringOrNil(runtime, u),
+                        stringOrNil(runtime, val)
+                    };
                 }
 
-                IRubyObject attr = RuntimeHelpers.invoke(context, attrClass, "new", args);
-                rubyAttr.add(attr);
+                rubyAttr.append( RuntimeHelpers.invoke(context, attrClass, "new", args) );
             }
         }
 
-        if (localName == null || localName.equals("")) localName = getLocalPart(qName);
+        if (localName == null || localName.isEmpty()) localName = getLocalPart(qName);
         populateCharacters();
         call("start_element_namespace",
-             stringOrNil(ruby, localName),
+             stringOrNil(runtime, localName),
              rubyAttr,
-             stringOrNil(ruby, getPrefix(qName)),
-             stringOrNil(ruby, uri),
+             stringOrNil(runtime, getPrefix(qName)),
+             stringOrNil(runtime, uri),
              rubyNSAttr);
     }
 
-    private static String[] emptyAttrs =
-        {"checked", "compact", "declare", "defer", "disabled", "ismap", "multiple",
-         "noresize", "nohref", "noshade", "nowrap", "readonly", "selected"};
-
-    private boolean isEmptyAttr(String name) {
-        for (String emptyAttr : emptyAttrs) {
-            if (emptyAttr.equals(name)) return true;
-        }
-        return false;
+    static final Set<String> EMPTY_ATTRS;
+    static {
+        final String[] emptyAttrs = {
+            "checked", "compact", "declare", "defer", "disabled", "ismap", "multiple",
+            "noresize", "nohref", "noshade", "nowrap", "readonly", "selected"
+        };
+        EMPTY_ATTRS = new HashSet<String>(Arrays.asList(emptyAttrs));
     }
-
-    public Integer getLine() {
-        return locator.getLineNumber();
+    
+    private static boolean isEmptyAttr(String name) {
+        return EMPTY_ATTRS.contains(name);
     }
-
-    public Integer getColumn() {
-        return locator.getColumnNumber() - 1;
+    
+    public final Integer getLine() { // -1 if none is available
+        final int line = locator.getLineNumber();
+        return line == -1 ? null : line;
     }
-
-    private boolean isFromFragmentHandler() {
-        if (object != null && object instanceof RubyObject) {
-            RubyObject rubyObj = (RubyObject)object;
-            IRubyObject document = rubyObj.getInstanceVariable("@document");
-            if (document != null) {
-                String name = document.getMetaClass().getName();
-                if ("Nokogiri::XML::FragmentHandler".equals(name)) {
-                    return true;
-                }
-            }
-        }
-        return false;
+    
+    public final Integer getColumn() { // -1 if none is available
+        final int column = locator.getColumnNumber();
+        return column == -1 ? null : column - 1;
     }
 
     @Override
-    public void endElement(String uri, String localName, String qName) throws SAXException {
+    public void endElement(String uri, String localName, String qName) {
         populateCharacters();
         call("end_element_namespace",
-             stringOrNil(ruby, localName),
-             stringOrNil(ruby, getPrefix(qName)),
-             stringOrNil(ruby, uri));
+             stringOrNil(runtime, localName),
+             stringOrNil(runtime, getPrefix(qName)),
+             stringOrNil(runtime, uri));
     }
 
     @Override
-    public void characters(char[] ch, int start, int length) throws SAXException {
+    public void characters(char[] ch, int start, int length) {
         charactersBuilder.append(ch, start, length);
     }
 
     @Override
-    public void comment(char[] ch, int start, int length) throws SAXException {
+    public void comment(char[] ch, int start, int length) {
         populateCharacters();
-        call("comment", ruby.newString(new String(ch, start, length)));
+        call("comment", runtime.newString(new String(ch, start, length)));
     }
 
     @Override
-    public void startCDATA() throws SAXException {
+    public void startCDATA() {
         populateCharacters();
     }
 
     @Override
-    public void endCDATA() throws SAXException {
-        call("cdata_block", ruby.newString(charactersBuilder.toString()));
+    public void endCDATA() {
+        call("cdata_block", runtime.newString(charactersBuilder.toString()));
         charactersBuilder.setLength(0);
     }
 
     @Override
-    public void error(SAXParseException saxpe) {
-        addError(XmlSyntaxError.createError(ruby, saxpe));
-        call("error", ruby.newString(saxpe.getMessage()));
+    public void error(SAXParseException ex) {
+        try {
+            final String msg = ex.getMessage();
+            call("error", runtime.newString(msg == null ? "" : msg));
+            addError(new RaiseException(XmlSyntaxError.createError(runtime, ex), true));
+        } catch(RaiseException e) {
+            addError(e);
+        }
     }
 
     @Override
-    public void fatalError(SAXParseException saxpe) throws SAXException
-    {
-        addError(XmlSyntaxError.createFatalError(ruby, saxpe));
-        call("error", ruby.newString(saxpe.getMessage()));
+    public void fatalError(SAXParseException ex) {
+        try {
+            final String msg = ex.getMessage();
+            call("error", runtime.newString(msg == null ? "" : msg));
+            addError(new RaiseException(XmlSyntaxError.createFatalError(runtime, ex), true));
+
+        } catch(RaiseException e) {
+            addError(e);
+        }
     }
 
     @Override
-    public void warning(SAXParseException saxpe) {
-        //System.out.println("warning: " + saxpe);
-        call("warning", ruby.newString(saxpe.getMessage()));
+    public void warning(SAXParseException ex) {
+        final String msg = ex.getMessage();
+        call("warning", runtime.newString(msg == null ? "" : msg));
     }
 
-    protected synchronized void addError(XmlSyntaxError e) {
+    protected synchronized void addError(RaiseException e) {
         errors.add(e);
     }
 
@@ -280,30 +283,28 @@ public class NokogiriHandler extends DefaultHandler2 implements XmlDeclHandler {
         return errors.size();
     }
 
-    public synchronized IRubyObject getLastError() {
+    public synchronized RaiseException getLastError() {
         return errors.getLast();
     }
 
     private void call(String methodName) {
-        ThreadContext context = ruby.getCurrentContext();
+        ThreadContext context = runtime.getCurrentContext();
         RuntimeHelpers.invoke(context, document(context), methodName);
     }
 
     private void call(String methodName, IRubyObject argument) {
-        ThreadContext context = ruby.getCurrentContext();
+        ThreadContext context = runtime.getCurrentContext();
         RuntimeHelpers.invoke(context, document(context), methodName, argument);
     }
 
     private void call(String methodName, IRubyObject arg1, IRubyObject arg2) {
-        ThreadContext context = ruby.getCurrentContext();
+        ThreadContext context = runtime.getCurrentContext();
         RuntimeHelpers.invoke(context, document(context), methodName, arg1, arg2);
     }
 
-    private void call(String methodName, IRubyObject arg1, IRubyObject arg2,
-                      IRubyObject arg3) {
-        ThreadContext context = ruby.getCurrentContext();
-        RuntimeHelpers.invoke(context, document(context), methodName,
-                              arg1, arg2, arg3);
+    private void call(String methodName, IRubyObject arg1, IRubyObject arg2, IRubyObject arg3) {
+        ThreadContext context = runtime.getCurrentContext();
+        RuntimeHelpers.invoke(context, document(context), methodName, arg1, arg2, arg3);
     }
 
     private void call(String methodName,
@@ -312,26 +313,17 @@ public class NokogiriHandler extends DefaultHandler2 implements XmlDeclHandler {
                       IRubyObject arg2,
                       IRubyObject arg3,
                       IRubyObject arg4) {
-        IRubyObject[] args = new IRubyObject[5];
-        args[0] = arg0;
-        args[1] = arg1;
-        args[2] = arg2;
-        args[3] = arg3;
-        args[4] = arg4;
-        ThreadContext context = ruby.getCurrentContext();
-        RuntimeHelpers.invoke(context, document(context), methodName, args);
+        ThreadContext context = runtime.getCurrentContext();
+        RuntimeHelpers.invoke(context, document(context), methodName, arg0, arg1, arg2, arg3, arg4);
     }
 
     private IRubyObject document(ThreadContext context) {
-        if (object instanceof RubyObject) {
-            return ((RubyObject)object).fastGetInstanceVariable("@document");
-        }
-        return context.getRuntime().getNil();
+        return object.getInstanceVariables().getInstanceVariable("@document");
     }
 
     protected void populateCharacters() {
         if (charactersBuilder.length() > 0) {
-            call("characters", ruby.newString(charactersBuilder.toString()));
+            call("characters", runtime.newString(charactersBuilder.toString()));
             charactersBuilder.setLength(0);
         }
     }