nokogiri 1.4.3.1-java → 1.5.0-java

data/ext/java/nokogiri/internals/NokogiriXPathFunction.java

@@ -0,0 +1,141 @@
+/**
+ * (The MIT License)
+ *
+ * Copyright (c) 2008 - 2011:
+ *
+ * * {Aaron Patterson}[http://tenderlovemaking.com]
+ * * {Mike Dalessio}[http://mike.daless.io]
+ * * {Charles Nutter}[http://blog.headius.com]
+ * * {Sergio Arbeo}[http://www.serabe.com]
+ * * {Patrick Mahoney}[http://polycrystal.org]
+ * * {Yoko Harada}[http://yokolet.blogspot.com]
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package nokogiri.internals;
+
+import static nokogiri.internals.NokogiriHelpers.getNokogiriClass;
+
+import java.util.List;
+
+import javax.xml.xpath.XPathFunction;
+import javax.xml.xpath.XPathFunctionException;
+
+import nokogiri.NokogiriService;
+import nokogiri.XmlNode;
+import nokogiri.XmlNodeSet;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyBoolean;
+import org.jruby.RubyFloat;
+import org.jruby.RubyString;
+import org.jruby.javasupport.JavaUtil;
+import org.jruby.javasupport.util.RuntimeHelpers;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.w3c.dom.NodeList;
+
+/**
+ * Xpath function handler.
+ * 
+ * @author sergio
+ * @author Yoko Harada <yokolet@gmail.com>
+ */
+public class NokogiriXPathFunction implements XPathFunction {
+    private static NokogiriXPathFunction xpathFunction;
+    private IRubyObject handler;
+    private String name;
+    private int arity;
+    
+    public static NokogiriXPathFunction create(IRubyObject handler, String name, int arity) {
+        if (xpathFunction == null) xpathFunction = new NokogiriXPathFunction();
+        try {
+            NokogiriXPathFunction clone = (NokogiriXPathFunction) xpathFunction.clone();
+            clone.init(handler, name, arity);
+            return clone;
+        } catch (CloneNotSupportedException e) {
+            NokogiriXPathFunction freshXpathFunction = new NokogiriXPathFunction();
+            freshXpathFunction.init(handler, name, arity);
+            return freshXpathFunction;
+        }
+    }
+
+    private void init(IRubyObject handler, String name, int arity) {
+        this.handler = handler;
+        this.name = name;
+        this.arity = arity;
+    }
+
+    private NokogiriXPathFunction() {}
+
+    public Object evaluate(List args) throws XPathFunctionException {
+        if(args.size() != this.arity) {
+            throw new XPathFunctionException("arity does not match");
+        }
+        
+        Ruby ruby = this.handler.getRuntime();
+        ThreadContext context = ruby.getCurrentContext();
+
+        IRubyObject result = RuntimeHelpers.invoke(context, this.handler,
+                this.name, fromObjectToRubyArgs(args));
+
+        return fromRubyToObject(result);
+    }
+
+    private IRubyObject[] fromObjectToRubyArgs(List args) {
+        IRubyObject[] newArgs = new IRubyObject[args.size()];
+        for(int i = 0; i < args.size(); i++) {
+            newArgs[i] = fromObjectToRuby(args.get(i));
+        }
+        return newArgs;
+    }
+
+    private IRubyObject fromObjectToRuby(Object o) {
+        // argument object type is one of NodeList, String, Boolean, or Double.
+        Ruby runtime = this.handler.getRuntime();
+        if (o instanceof NodeList) {
+            XmlNodeSet xmlNodeSet = (XmlNodeSet)NokogiriService.XML_NODESET_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::NodeSet"));
+            xmlNodeSet.setNodeList((NodeList) o);
+            return xmlNodeSet;
+        } else {
+            return JavaUtil.convertJavaToUsableRubyObject(runtime, o);
+        }
+    }
+
+    private Object fromRubyToObject(IRubyObject o) {
+        Ruby runtime = this.handler.getRuntime();
+        if(o instanceof RubyString) {
+            return o.toJava(String.class);
+        } else if (o instanceof RubyFloat) {
+            return o.toJava(Double.class);
+        } else if (o instanceof RubyBoolean) {
+            return o.toJava(Boolean.class);
+        } else if (o instanceof XmlNodeSet) {
+            return (NodeList)o;
+        } else if (o instanceof RubyArray) {
+            XmlNodeSet xmlNodeSet = XmlNodeSet.newXmlNodeSet(runtime.getCurrentContext(), (RubyArray)o);
+            return (NodeList)xmlNodeSet;
+        } else /*if (o instanceof XmlNode)*/ {
+            return ((XmlNode) o).getNode();
+        }
+    }
+}

data/ext/java/nokogiri/internals/NokogiriXPathFunctionResolver.java

@@ -0,0 +1,73 @@
+/**
+ * (The MIT License)
+ *
+ * Copyright (c) 2008 - 2011:
+ *
+ * * {Aaron Patterson}[http://tenderlovemaking.com]
+ * * {Mike Dalessio}[http://mike.daless.io]
+ * * {Charles Nutter}[http://blog.headius.com]
+ * * {Sergio Arbeo}[http://www.serabe.com]
+ * * {Patrick Mahoney}[http://polycrystal.org]
+ * * {Yoko Harada}[http://yokolet.blogspot.com]
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package nokogiri.internals;
+
+import javax.xml.namespace.QName;
+import javax.xml.xpath.XPathFunction;
+import javax.xml.xpath.XPathFunctionResolver;
+
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ * Xpath function resolver class, which is used in XmlXpathContext. 
+ * 
+ * @author sergio
+ * @author Yoko Harada <yokolet@gmail.com>
+ */
+public class NokogiriXPathFunctionResolver implements XPathFunctionResolver {
+    private static NokogiriXPathFunctionResolver resolver;
+    private IRubyObject handler;
+    
+    public static NokogiriXPathFunctionResolver create(IRubyObject handler) {
+        if (resolver == null) resolver = new NokogiriXPathFunctionResolver();
+        try {
+            NokogiriXPathFunctionResolver clone = (NokogiriXPathFunctionResolver) resolver.clone();
+            clone.setHandler(handler);
+            return clone;
+        } catch (CloneNotSupportedException e) {
+            NokogiriXPathFunctionResolver freshResolver = new NokogiriXPathFunctionResolver();
+            freshResolver.setHandler(handler);
+            return freshResolver;
+        }
+    }
+    
+    private NokogiriXPathFunctionResolver() {}
+    
+    private void setHandler(IRubyObject handler) {
+        this.handler = handler;
+    }
+
+    public XPathFunction resolveFunction(QName name, int arity) {
+        return NokogiriXPathFunction.create(handler, name.getLocalPart(), arity);
+    }
+}

data/ext/java/nokogiri/internals/NokogiriXPathVariableResolver.java

@@ -0,0 +1,67 @@
+/**
+ * (The MIT License)
+ *
+ * Copyright (c) 2008 - 2011:
+ *
+ * * {Aaron Patterson}[http://tenderlovemaking.com]
+ * * {Mike Dalessio}[http://mike.daless.io]
+ * * {Charles Nutter}[http://blog.headius.com]
+ * * {Sergio Arbeo}[http://www.serabe.com]
+ * * {Patrick Mahoney}[http://polycrystal.org]
+ * * {Yoko Harada}[http://yokolet.blogspot.com]
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package nokogiri.internals;
+
+import java.util.HashMap;
+import javax.xml.namespace.QName;
+import javax.xml.xpath.XPathVariableResolver;
+
+/**
+ * XPath variable support
+ * 
+ * @author Ken Bloom <kbloom@gmail.com>
+ * @author Yoko Harada <yokolet@gmail.com>
+ */
+public class NokogiriXPathVariableResolver implements XPathVariableResolver {
+    private static NokogiriXPathVariableResolver resolver;
+    private HashMap<QName,String> variables = new HashMap<QName,String>();
+
+    public static NokogiriXPathVariableResolver create() {
+        if (resolver == null) resolver = new NokogiriXPathVariableResolver();
+        try {
+            NokogiriXPathVariableResolver clone = (NokogiriXPathVariableResolver) resolver.clone();
+            return clone;
+        } catch (CloneNotSupportedException e) {
+            NokogiriXPathVariableResolver freshResolver = new NokogiriXPathVariableResolver();
+            return freshResolver;
+        }
+    }
+    
+    private NokogiriXPathVariableResolver() {}
+    
+    public Object resolveVariable(QName variableName){
+        return variables.get(variableName);
+    }
+    public void registerVariable(String name,String value){
+        variables.put(new QName(name),value);
+    }
+}

data/ext/java/nokogiri/internals/NokogiriXsltErrorListener.java

@@ -0,0 +1,86 @@
+/**
+ * (The MIT License)
+ *
+ * Copyright (c) 2008 - 2011:
+ *
+ * * {Aaron Patterson}[http://tenderlovemaking.com]
+ * * {Mike Dalessio}[http://mike.daless.io]
+ * * {Charles Nutter}[http://blog.headius.com]
+ * * {Sergio Arbeo}[http://www.serabe.com]
+ * * {Patrick Mahoney}[http://polycrystal.org]
+ * * {Yoko Harada}[http://yokolet.blogspot.com]
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package nokogiri.internals;
+
+import javax.xml.transform.ErrorListener;
+import javax.xml.transform.TransformerException;
+
+/**
+ * Error Listener for XSLT transformer
+ * 
+ * @author Yoko Harada <yokolet@gmail.com>
+ */
+public class NokogiriXsltErrorListener implements ErrorListener {
+    public enum ErrorType {
+        WARNING,
+        ERROR,
+        FATAL
+    }
+
+    private ErrorType type;
+    private String errorMessage;
+    private Exception exception;
+
+    public void warning(TransformerException ex) throws TransformerException {
+        type = ErrorType.WARNING;
+        setError(ex);
+    }
+
+    public void error(TransformerException ex) throws TransformerException {
+       type = ErrorType.ERROR;
+       setError(ex);
+    }
+
+    public void fatalError(TransformerException ex) throws TransformerException {
+        type = ErrorType.FATAL;
+        setError(ex);
+    }
+    
+    private void setError(TransformerException ex) {
+        errorMessage = ex.getMessage();
+        exception = ex;
+    }
+    
+    public String getErrorMessage() {
+        return errorMessage;
+    }
+    
+    public ErrorType getErrorType() {
+        return type;
+    }
+    
+    public Exception getException() {
+        return exception;
+    }
+
+}

data/ext/java/nokogiri/internals/ParserContext.java

@@ -0,0 +1,276 @@
+/**
+ * (The MIT License)
+ *
+ * Copyright (c) 2008 - 2011:
+ *
+ * * {Aaron Patterson}[http://tenderlovemaking.com]
+ * * {Mike Dalessio}[http://mike.daless.io]
+ * * {Charles Nutter}[http://blog.headius.com]
+ * * {Sergio Arbeo}[http://www.serabe.com]
+ * * {Patrick Mahoney}[http://polycrystal.org]
+ * * {Yoko Harada}[http://yokolet.blogspot.com]
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package nokogiri.internals;
+
+import static nokogiri.internals.NokogiriHelpers.rubyStringToString;
+import static nokogiri.internals.NokogiriHelpers.adjustSystemIdIfNecessary;
+import static org.jruby.javasupport.util.RuntimeHelpers.invoke;
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyIO;
+import org.jruby.RubyObject;
+import org.jruby.RubyString;
+import org.jruby.RubyStringIO;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
+import org.jruby.util.TypeConverter;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+import org.xml.sax.ext.EntityResolver2;
+
+/**
+ * Base class for the various parser contexts.  Handles converting
+ * Ruby objects to InputSource objects.
+ *
+ * @author Patrick Mahoney <pat@polycrystal.org>
+ * @author Yoko Harada <yokolet@gmail.com>
+ */
+public class ParserContext extends RubyObject {
+    protected InputSource source = null;
+
+    /**
+     * Create a file base input source taking into account the current
+     * directory of <code>runtime</code>.
+     */
+    public static InputSource resolveEntity(Ruby runtime, String publicId, String baseURI, String systemId)
+        throws IOException {
+        InputSource s = new InputSource();
+        String adjusted = adjustSystemIdIfNecessary(runtime.getCurrentDirectory(), runtime.getInstanceConfig().getScriptFileName(), baseURI, systemId);
+        if (adjusted == null && publicId == null) {
+            throw runtime.newRuntimeError("SystemId \"" + systemId + "\" is not correct.");
+        }
+        s.setSystemId(adjusted);
+        s.setPublicId(publicId);
+        return s;
+    }
+
+    public ParserContext(Ruby runtime) {
+        // default to class 'Object' because this class isn't exposed to Ruby
+        super(runtime, runtime.getObject());
+    }
+
+    public ParserContext(Ruby runtime, RubyClass klass) {
+        super(runtime, klass);
+    }
+
+    protected InputSource getInputSource() {
+        return source;
+    }
+
+    /**
+     * Set the InputSource from <code>url</code> or <code>data</code>,
+     * which may be an IO object, a String, or a StringIO.
+     */
+    public void setInputSource(ThreadContext context, IRubyObject data, IRubyObject url) {
+        Ruby ruby = context.getRuntime();
+        String path = (String) url.toJava(String.class);
+        if (isAbsolutePath(path)) {
+            source = new InputSource();
+            source.setSystemId(path);
+            return;
+        }
+        RubyString stringData = null;
+        if (invoke(context, data, "respond_to?",
+                   ruby.newSymbol("to_io").to_sym()).isTrue()) {
+            /* IO or other object that responds to :to_io */
+            RubyIO io =
+                (RubyIO) TypeConverter.convertToType(data,
+                                                     ruby.getIO(),
+                                                     "to_io");
+            source = new InputSource(io.getInStream());
+        } else if (((RubyObject)data).getInstanceVariable("@io") != null) {
+            // in case of EncodingReader is used
+            // since EncodingReader won't respond to :to_io
+            RubyObject dataObject = (RubyObject) ((RubyObject)data).getInstanceVariable("@io");
+            if (dataObject instanceof RubyIO) {
+                RubyIO io = (RubyIO)dataObject;
+                source = new InputSource(io.getInStream());
+            } else if (dataObject instanceof RubyStringIO) {
+                stringData = (RubyString)((RubyStringIO)dataObject).string();
+            }
+        } else {
+            if (invoke(context, data, "respond_to?",
+                          ruby.newSymbol("string").to_sym()).isTrue()) {
+                /* StringIO or other object that responds to :string */
+                stringData = invoke(context, data, "string").convertToString();
+            } else if (data instanceof RubyString) {
+                stringData = (RubyString) data;
+            } else {
+                throw ruby.newArgumentError(
+                    "must be kind_of String or respond to :to_io or :string");
+            }
+        }
+        if (stringData != null) {
+            ByteList bytes = stringData.getByteList();
+            source = new InputSource(new ByteArrayInputStream(bytes.unsafeBytes(), bytes.begin(), bytes.length()));
+        }
+    }
+    
+    private boolean isAbsolutePath(String url) {
+        if (url == null) return false;
+        return (new File(url)).isAbsolute();
+    }
+
+    /**
+     * Set the InputSource to read from <code>file</code>, a String filename.
+     */
+    public void setInputSourceFile(ThreadContext context, IRubyObject file) {
+        String filename = rubyStringToString(file);
+
+        try{
+            source = resolveEntity(context.getRuntime(), null, null, filename);
+        } catch (Exception e) {
+            throw RaiseException.createNativeRaiseException(context.getRuntime(), e);
+        }
+
+    }
+
+    /**
+     * Set the InputSource from <code>stream</code>.
+     */
+    public void setInputSource(InputStream stream) {
+        source = new InputSource(stream);
+    }
+
+    /**
+     * Wrap Nokogiri parser options in a utility class.  This is
+     * read-only.
+     */
+    public static class Options {
+        protected static final long STRICT = 0;
+        protected static final long RECOVER = 1;
+        protected static final long NOENT = 2;
+        protected static final long DTDLOAD = 4;
+        protected static final long DTDATTR = 8;
+        protected static final long DTDVALID = 16;
+        protected static final long NOERROR = 32;
+        protected static final long NOWARNING = 64;
+        protected static final long PEDANTIC = 128;
+        protected static final long NOBLANKS = 256;
+        protected static final long SAX1 = 512;
+        protected static final long XINCLUDE = 1024;
+        protected static final long NONET = 2048;
+        protected static final long NODICT = 4096;
+        protected static final long NSCLEAN = 8192;
+        protected static final long NOCDATA = 16384;
+        protected static final long NOXINCNODE = 32768;
+
+        public boolean strict;
+        public boolean recover;
+        public boolean noEnt;
+        public boolean dtdLoad;
+        public boolean dtdAttr;
+        public boolean dtdValid;
+        public boolean noError;
+        public boolean noWarning;
+        public boolean pedantic;
+        public boolean noBlanks;
+        public boolean sax1;
+        public boolean xInclude;
+        public boolean noNet;
+        public boolean noDict;
+        public boolean nsClean;
+        public boolean noCdata;
+        public boolean noXIncNode;
+
+        protected static boolean test(long options, long mask) {
+            return ((options & mask) == mask);
+        }
+
+        public Options(long options) {
+            strict = ((options & RECOVER) == STRICT);
+            recover = test(options, RECOVER);
+            noEnt = test(options, NOENT);
+            dtdLoad = test(options, DTDLOAD);
+            dtdAttr = test(options, DTDATTR);
+            dtdValid = test(options, DTDVALID);
+            noError = test(options, NOERROR);
+            noWarning = test(options, NOWARNING);
+            pedantic = test(options, PEDANTIC);
+            noBlanks = test(options, NOBLANKS);
+            sax1 = test(options, SAX1);
+            xInclude = test(options, XINCLUDE);
+            noNet = test(options, NONET);
+            noDict = test(options, NODICT);
+            nsClean = test(options, NSCLEAN);
+            noCdata = test(options, NOCDATA);
+            noXIncNode = test(options, NOXINCNODE);
+        }
+    }
+
+    /**
+     * 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 static class ChdirEntityResolver implements EntityResolver2 {
+        protected Ruby runtime;
+
+        public ChdirEntityResolver(Ruby runtime) {
+            super();
+            this.runtime = runtime;
+        }
+
+        @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(null, publicId, null, systemId);
+        }
+
+        @Override
+        public InputSource resolveEntity(String name,
+                                         String publicId,
+                                         String baseURI,
+                                         String systemId)
+            throws SAXException, IOException {
+            return ParserContext.resolveEntity(runtime, publicId, baseURI, systemId);
+        }
+
+    }
+
+}