nokogiri-backport 1.11.0

data/ext/java/nokogiri/internals/NokogiriNamespaceCache.java

@@ -0,0 +1,217 @@
+/**
+ * (The MIT License)
+ *
+ * Copyright (c) 2008 - 2014:
+ *
+ * * {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.isNamespace;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import nokogiri.XmlNamespace;
+
+import org.w3c.dom.Attr;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+
+/**
+ * Cache of namespaces of each node. XmlDocument has one cache of this class.
+ * 
+ * @author sergio
+ * @author Yoko Harada <yokolet@gmail.com>
+ */
+public class NokogiriNamespaceCache {
+
+    private final Map<CacheKey, CacheEntry> cache;  // pair of the index of a given key and entry
+    private XmlNamespace defaultNamespace = null;
+
+    public NokogiriNamespaceCache() {
+        this.cache = new LinkedHashMap<CacheKey, CacheEntry>(4);
+    }
+
+    public NokogiriNamespaceCache(NokogiriNamespaceCache cache) {
+        this.cache = new LinkedHashMap<CacheKey, CacheEntry>(cache.size() + 2);
+        this.cache.putAll(cache.cache);
+    }
+
+    public XmlNamespace getDefault() {
+        return defaultNamespace;
+    }
+
+    public XmlNamespace get(String prefix, String href) {
+        if (href == null) return null;
+
+        CacheEntry value = cache.get(new CacheKey(prefix, href));
+        return value == null ? null : value.namespace;
+    }
+
+    public XmlNamespace get(Node node, String prefix) {
+        if (prefix == null) return defaultNamespace;
+        for (Map.Entry<CacheKey, CacheEntry> entry : cache.entrySet()) {
+            if (entry.getKey().prefix.equals(prefix)) {
+                if (entry.getValue().isOwner(node)) {
+                    return entry.getValue().namespace;
+                }
+            }
+        }
+        return null;
+    }
+
+    public List<XmlNamespace> get(String prefix) {
+        List<XmlNamespace> namespaces = new ArrayList<XmlNamespace>();
+        if (prefix == null) {
+            namespaces.add(defaultNamespace);
+            return namespaces;
+        }
+        for (Map.Entry<CacheKey, CacheEntry> entry : cache.entrySet()) {
+            if (entry.getKey().prefix.equals(prefix)) {
+                namespaces.add(entry.getValue().namespace);
+            }
+        }
+        return namespaces;
+    }
+
+    public List<XmlNamespace> get(Node node) {
+        List<XmlNamespace> namespaces = new ArrayList<XmlNamespace>();
+        for (Map.Entry<CacheKey, CacheEntry> entry : cache.entrySet()) {
+            if (entry.getValue().isOwner(node)) {
+                namespaces.add(entry.getValue().namespace);
+            }
+        }
+        return namespaces;
+    }
+
+    public void put(XmlNamespace namespace, Node ownerNode) {
+        String prefix = namespace.getPrefix();
+        String href = namespace.getHref();
+        if (href == null) return;
+
+        CacheKey key = new CacheKey(prefix, href);
+        if (cache.get(key) != null) return;
+        cache.put(key, new CacheEntry(namespace, ownerNode));
+        if ("".equals(prefix)) defaultNamespace = namespace;
+    }
+
+    public void remove(Node ownerNode) {
+        String prefix = ownerNode.getPrefix();
+        String href = ownerNode.getNamespaceURI();
+        if (href == null) return;
+
+        cache.remove(new CacheKey(prefix, href));
+    }
+
+    public int size() {
+        return cache.size();
+    }
+
+    public void clear() {
+        // removes namespace declarations from node
+        for (CacheEntry entry : cache.values()) {
+            NamedNodeMap attributes = entry.ownerNode.getAttributes();
+            for (int j=0; j<attributes.getLength(); j++) {
+                String name = ((Attr) attributes.item(j)).getName();
+                if (isNamespace(name)) {
+                    attributes.removeNamedItem(name);
+                }
+            }
+        }
+        cache.clear();
+        defaultNamespace = null;
+    }
+
+    public void replaceNode(Node oldNode, Node newNode) {
+        for (Map.Entry<CacheKey, CacheEntry> entry : cache.entrySet()) {
+            if (entry.getValue().isOwner(oldNode)) {
+                entry.getValue().replaceOwner(newNode);
+            }
+        }
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getName() + '@' + Integer.toHexString(hashCode()) + '(' + cache + "default=" + defaultNamespace + ')';
+    }
+
+    private static class CacheKey {
+        final String prefix;
+        final String href;
+
+        CacheKey(String prefix, String href) {
+            this.prefix = prefix;
+            this.href = href;
+        }
+
+        @Override
+        public boolean equals(final Object obj) {
+            if (obj instanceof CacheKey) {
+                CacheKey that = (CacheKey) obj;
+                return prefix == null ? that.prefix == null : prefix.equals(that.prefix) && href.equals(that.href);
+            }
+            return false;
+        }
+
+        @Override
+        public int hashCode() {
+            return (prefix == null ? 0 : prefix.hashCode()) + 37 * href.hashCode();
+        }
+
+        @Override
+        public String toString() {
+            return '[' + prefix + ']' + href;
+        }
+    }
+
+    private static class CacheEntry {
+        final XmlNamespace namespace;
+        private Node ownerNode;
+
+        CacheEntry(XmlNamespace namespace, Node ownerNode) {
+            this.namespace = namespace;
+            this.ownerNode = ownerNode;
+        }
+
+        boolean isOwner(Node node) {
+            return ownerNode.isSameNode(node);
+        }
+
+        void replaceOwner(Node newNode) {
+            this.ownerNode = newNode;
+        }
+
+        @Override
+        public String toString() {
+            return namespace.toString();
+        }
+    }
+}

data/ext/java/nokogiri/internals/NokogiriNamespaceContext.java

@@ -0,0 +1,127 @@
+/**
+ * (The MIT License)
+ *
+ * Copyright (c) 2008 - 2012:
+ *
+ * * {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.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import javax.xml.XMLConstants;
+import javax.xml.namespace.NamespaceContext;
+
+/**
+ * Holder of each node's namespace.
+ * 
+ * @author Yoko Harada <yokolet@gmail.com>
+ *
+ */
+public final class NokogiriNamespaceContext implements NamespaceContext {
+
+    /*
+     * these constants have matching declarations in
+     * ext/nokogiri/xml_xpath_context.c
+     */
+    public static final String NOKOGIRI_PREFIX = "nokogiri";
+    public static final String NOKOGIRI_URI = "http://www.nokogiri.org/default_ns/ruby/extensions_functions";
+
+    public static final String NOKOGIRI_BUILTIN_PREFIX = "nokogiri-builtin";
+    public static final String NOKOGIRI_BUILTIN_URI = "https://www.nokogiri.org/default_ns/ruby/builtins";
+    
+    private final Map<String,String> register;
+
+    public static NokogiriNamespaceContext create() {
+        return new NokogiriNamespaceContext();
+    }
+    
+    private NokogiriNamespaceContext() {
+        register = new HashMap<String, String>(6, 1);
+        register.put(NOKOGIRI_PREFIX, NOKOGIRI_URI);
+        register.put(NOKOGIRI_BUILTIN_PREFIX, NOKOGIRI_BUILTIN_URI);
+        register.put("xml", "http://www.w3.org/XML/1998/namespace");
+        register.put("xhtml", "http://www.w3.org/1999/xhtml");
+    }
+
+    public String getNamespaceURI(String prefix) {
+    	if (prefix == null) {
+            throw new IllegalArgumentException();
+        }
+        String uri = this.register.get(prefix);
+        if (uri != null) {
+            return uri;
+        }
+
+        if (prefix.equals(XMLConstants.XMLNS_ATTRIBUTE)) {
+            uri = this.register.get(XMLConstants.XMLNS_ATTRIBUTE);
+            return (uri == null) ? XMLConstants.XMLNS_ATTRIBUTE_NS_URI : uri;
+        }
+
+        return XMLConstants.NULL_NS_URI;
+    }
+
+    public String getPrefix(String uri) {
+    	if (uri == null) {
+            throw new IllegalArgumentException("uri is null");
+        }
+        Set<Entry<String, String>> entries = register.entrySet();
+        for (Entry<String, String> entry : entries) {
+            if (uri.equals(entry.getValue())) {
+                return entry.getKey();
+            }
+        }
+        return null;
+    }
+
+    public Iterator<String> getPrefixes(String uri) {
+        Set<Entry<String, String>> entries = register.entrySet();
+        ArrayList<String> list = new ArrayList<String>(entries.size());
+        for (Entry<String, String> entry : entries) {
+            if (uri.equals(entry.getValue())) {
+                list.add(entry.getKey());
+            }
+        }
+        return list.iterator();
+    }
+    
+    public Set<String> getAllPrefixes() {
+        return register.keySet();
+    }
+
+    public void registerNamespace(String prefix, String uri) {
+        if ("xmlns".equals(prefix)) prefix = "";
+        register.put(prefix, uri);
+    }
+
+}

data/ext/java/nokogiri/internals/NokogiriNonStrictErrorHandler.java

@@ -0,0 +1,100 @@
+/**
+ * (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 org.apache.xerces.xni.parser.XMLParseException;
+import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
+
+/**
+ * Error Handler for XML document when recover is true (default).
+ * 
+ * @author sergio
+ * @author Yoko Harada <yokolet@gmail.com>
+ */
+public class NokogiriNonStrictErrorHandler extends NokogiriErrorHandler{
+    public NokogiriNonStrictErrorHandler(boolean noerror, boolean nowarning) {
+        super(noerror, nowarning);
+    }
+
+    public void warning(SAXParseException ex) throws SAXException {
+        errors.add(ex);
+    }
+
+    public void error(SAXParseException ex) throws SAXException {
+        errors.add(ex);
+    }
+
+    public void fatalError(SAXParseException ex) throws SAXException {
+        // fix #837
+        // Xerces won't skip the reference entity (and other invalid) constructs
+        // found in the prolog, instead it will keep calling this method and we'll
+        // keep inserting the error in the document errors array until we run
+        // out of memory
+        errors.add(ex);
+        String message = ex.getMessage();
+
+        // The problem with Xerces is that some errors will cause the
+        // parser not to advance the reader and it will keep reporting
+        // the same error over and over, which will cause the parser
+        // to enter an infinite loop unless we throw the exception.
+        if (message != null && isFatal(message)) {
+          throw ex;
+        }
+    }
+
+    public void error(String domain, String key, XMLParseException e) {
+        errors.add(e);
+    }
+
+    public void fatalError(String domain, String key, XMLParseException e) {
+        errors.add(e);
+    }
+
+    public void warning(String domain, String key, XMLParseException e) {
+        errors.add(e);
+    }
+
+    /*
+     * Determine whether this is a fatal error that should cause
+     * the parsing to stop, or an error that can be ignored.
+     */
+    private static boolean isFatal(String msg) {
+        String msgLowerCase = msg.toLowerCase();
+        return
+          msgLowerCase.contains("in prolog") ||
+          msgLowerCase.contains("limit") ||
+          msgLowerCase.contains("preceding the root element must be well-formed") ||
+          msgLowerCase.contains("following the root element must be well-formed");
+    }
+}

data/ext/java/nokogiri/internals/NokogiriNonStrictErrorHandler4NekoHtml.java

@@ -0,0 +1,121 @@
+/**
+ * (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 org.apache.xerces.xni.parser.XMLParseException;
+import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
+
+/**
+ * Non-strict error handler for NekoHtml.
+ * 
+ * NekoHtml adds too many warnings, which makes later processing hard. For example,
+ * Nokogiri wants to know whether number of errors have been increased or not to judge 
+ * availability of creating NodeSet from a given fragment. When the fragment nodes 
+ * are to be created from HTML document, which means NekoHtml is used, always errors
+ * increases. As a result, even though the given fragment is correct HTML, NodeSet
+ * base on the given fragment won't be created. This is why all warnings are eliminated.
+ * 
+ * @author Yoko Harada <yokolet@gmail.com>
+ */
+public class NokogiriNonStrictErrorHandler4NekoHtml extends NokogiriErrorHandler {
+    
+    public NokogiriNonStrictErrorHandler4NekoHtml(boolean nowarning) {
+        super(false, nowarning);
+    }
+    
+    public NokogiriNonStrictErrorHandler4NekoHtml(boolean noerror, boolean nowarning) {
+        super(noerror, nowarning);
+    }
+
+    public void warning(SAXParseException ex) throws SAXException {
+        //noop. NekoHtml adds too many warnings.
+    }
+
+    public void error(SAXParseException ex) throws SAXException {
+        errors.add(ex);
+    }
+
+    public void fatalError(SAXParseException ex) throws SAXException {
+        errors.add(ex);
+    }
+
+    /**
+     * Implementation of org.apache.xerces.xni.parser.XMLErrorHandler. This method
+     * is invoked during parsing fired by HtmlDomParserContext and is a NekoHtml requirement.
+     * 
+     * @param domain The domain of the error. The domain can be any string but is 
+     *               suggested to be a valid URI. The domain can be used to conveniently
+     *               specify a web site location of the relevant specification or 
+     *               document pertaining to this warning.
+     * @param key The error key. This key can be any string and is implementation
+     *            dependent.
+     * @param e Exception.
+     */
+    public void error(String domain, String key, XMLParseException e) {
+        errors.add(e);
+    }
+
+    /**
+     * Implementation of org.apache.xerces.xni.parser.XMLErrorHandler. This method
+     * is invoked during parsing fired by HtmlDomParserContext and is a NekoHtml requirement.
+     * 
+     * @param domain The domain of the fatal error. The domain can be any string but is 
+     *               suggested to be a valid URI. The domain can be used to conveniently
+     *               specify a web site location of the relevant specification or 
+     *               document pertaining to this warning.
+     * @param key The fatal error key. This key can be any string and is implementation
+     *            dependent.
+     * @param e Exception.
+     */
+    public void fatalError(String domain, String key, XMLParseException e) {
+        errors.add(e);
+    }
+
+    /**
+     * Implementation of org.apache.xerces.xni.parser.XMLErrorHandler. This method
+     * is invoked during parsing fired by HtmlDomParserContext and is a NekoHtml requirement.
+     * 
+     * @param domain The domain of the warning. The domain can be any string but is 
+     *               suggested to be a valid URI. The domain can be used to conveniently
+     *               specify a web site location of the relevant specification or 
+     *               document pertaining to this warning.
+     * @param key The warning key. This key can be any string and is implementation
+     *            dependent.
+     * @param e Exception.
+     */
+    public void warning(String domain, String key, XMLParseException e) {
+        errors.add(e);
+    }
+
+}

data/ext/java/nokogiri/internals/NokogiriStrictErrorHandler.java

@@ -0,0 +1,78 @@
+/**
+ * (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 org.apache.xerces.xni.parser.XMLParseException;
+import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
+
+/**
+ * Strict error handler. Even though strict is specified, Nokogiri allows to go further
+ * when NOERROR or/both NOWARNING is/are true.
+ * 
+ * @author sergio
+ * @author Yoko Harada <yokolet@gmail.com>
+ */
+public class NokogiriStrictErrorHandler extends NokogiriErrorHandler {
+    public NokogiriStrictErrorHandler(boolean noerror, boolean nowarning) {
+        super(noerror, nowarning);
+    }
+
+    public void warning(SAXParseException spex) throws SAXException {
+        if (!nowarning) throw spex;
+        else errors.add(spex);
+    }
+
+    public void error(SAXParseException spex) throws SAXException {
+        if (!noerror) throw spex;
+        else errors.add(spex);
+    }
+
+    public void fatalError(SAXParseException spex) throws SAXException {
+        throw spex;
+    }
+
+    public void error(String domain, String key, XMLParseException e) throws XMLParseException {
+        if (!noerror) throw e;
+        else errors.add(e);
+    }
+
+    public void fatalError(String domain, String key, XMLParseException e) throws XMLParseException {
+        throw e;
+    }
+
+    public void warning(String domain, String key, XMLParseException e) throws XMLParseException {
+        if (!nowarning) throw e;
+        if (!usesNekoHtml(domain)) errors.add(e);
+    }
+}