nokogiri-backport 1.11.0

data/ext/java/nokogiri/internals/NokogiriHelpers.java

@@ -0,0 +1,734 @@
+/**
+ * (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 java.io.ByteArrayInputStream;
+import java.io.File;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.charset.Charset;
+import java.util.List;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyString;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
+import org.w3c.dom.Attr;
+import org.w3c.dom.DOMException;
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+import nokogiri.HtmlDocument;
+import nokogiri.NokogiriService;
+import nokogiri.XmlAttr;
+import nokogiri.XmlCdata;
+import nokogiri.XmlComment;
+import nokogiri.XmlDocument;
+import nokogiri.XmlDtd;
+import nokogiri.XmlElement;
+import nokogiri.XmlEntityReference;
+import nokogiri.XmlNamespace;
+import nokogiri.XmlNode;
+import nokogiri.XmlProcessingInstruction;
+import nokogiri.XmlText;
+import nokogiri.XmlXpathContext;
+
+/**
+ * A class for various utility methods.
+ * 
+ * @author serabe
+ * @author Patrick Mahoney <pat@polycrystal.org>
+ * @author Yoko Harada <yokolet@gmail.com>
+ */
+public class NokogiriHelpers {
+    public static final String CACHED_NODE = "NOKOGIRI_CACHED_NODE";
+    public static final String ROOT_NODE_INVALID = "NOKOGIRI_ROOT_NODE_INVALID";
+    public static final String ENCODED_STRING = "NOKOGIRI_ENCODED_STRING";
+
+    public static XmlNode getCachedNode(Node node) {
+        return (XmlNode) node.getUserData(CACHED_NODE);
+    }
+
+    public static void clearCachedNode(Node node) {
+        node.setUserData(CACHED_NODE, null, null);
+    }
+
+    public static void clearXpathContext(Node node) {
+        if (node == null) return;
+
+        Node ownerDocument = node.getOwnerDocument();
+        if (ownerDocument == null) {
+            ownerDocument = node;
+        }
+        ownerDocument.setUserData(XmlXpathContext.XPATH_CONTEXT, null, null);
+    }
+
+    /**
+     * Get the XmlNode associated with the underlying
+     * <code>node</code>. Creates a new XmlNode (or appropriate subclass)
+     * or XmlNamespace wrapping <code>node</code> if there is no cached
+     * value.
+     */
+    public static IRubyObject getCachedNodeOrCreate(Ruby runtime, Node node) {
+        if (node == null) return runtime.getNil();
+        if (node.getNodeType() == Node.ATTRIBUTE_NODE && isNamespace(node.getNodeName())) {
+            XmlDocument xmlDocument = (XmlDocument) node.getOwnerDocument().getUserData(CACHED_NODE);
+            if (!(xmlDocument instanceof HtmlDocument)) {
+                String prefix = getLocalNameForNamespace(((Attr) node).getName(), null);
+                String href = ((Attr) node).getValue();
+                XmlNamespace xmlNamespace = xmlDocument.getNamespaceCache().get(prefix, href);
+                if (xmlNamespace != null) return xmlNamespace;
+                return XmlNamespace.createFromAttr(runtime, (Attr) node);
+            }
+        }
+        XmlNode xmlNode = getCachedNode(node);
+        if (xmlNode == null) {
+            xmlNode = (XmlNode) constructNode(runtime, node);
+            node.setUserData(CACHED_NODE, xmlNode, null);
+        }
+        return xmlNode;
+    }
+
+    /**
+     * Construct a new XmlNode wrapping <code>node</code>.  The proper
+     * subclass of XmlNode is chosen based on the type of
+     * <code>node</code>.
+     */
+    public static IRubyObject constructNode(Ruby runtime, Node node) {
+        if (node == null) return runtime.getNil();
+        // this is slow; need a way to cache nokogiri classes/modules somewhere
+        switch (node.getNodeType()) {
+            case Node.ELEMENT_NODE:
+                XmlElement xmlElement = (XmlElement) NokogiriService.XML_ELEMENT_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::Element"));
+                xmlElement.setNode(runtime, node);
+                return xmlElement;
+            case Node.ATTRIBUTE_NODE:
+                XmlAttr xmlAttr = (XmlAttr) NokogiriService.XML_ATTR_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::Attr"));
+                xmlAttr.setNode(runtime, node);
+                return xmlAttr;
+            case Node.TEXT_NODE:
+                XmlText xmlText = (XmlText) NokogiriService.XML_TEXT_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::Text"));
+                xmlText.setNode(runtime, node);
+                return xmlText;
+            case Node.COMMENT_NODE:
+                XmlComment xmlComment = (XmlComment) NokogiriService.XML_COMMENT_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::Comment"));
+                xmlComment.setNode(runtime, node);
+                return xmlComment;
+            case Node.ENTITY_NODE:
+                return new XmlNode(runtime, getNokogiriClass(runtime, "Nokogiri::XML::EntityDecl"), node);
+            case Node.ENTITY_REFERENCE_NODE:
+                XmlEntityReference xmlEntityRef = (XmlEntityReference) NokogiriService.XML_ENTITY_REFERENCE_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::EntityReference"));
+                xmlEntityRef.setNode(runtime, node);
+                return xmlEntityRef;
+            case Node.PROCESSING_INSTRUCTION_NODE:
+                XmlProcessingInstruction xmlProcessingInstruction = (XmlProcessingInstruction) NokogiriService.XML_PROCESSING_INSTRUCTION_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::ProcessingInstruction"));
+                xmlProcessingInstruction.setNode(runtime, node);
+                return xmlProcessingInstruction;
+            case Node.CDATA_SECTION_NODE:
+                XmlCdata xmlCdata = (XmlCdata) NokogiriService.XML_CDATA_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::CDATA"));
+                xmlCdata.setNode(runtime, node);
+                return xmlCdata;
+            case Node.DOCUMENT_NODE:
+                XmlDocument xmlDocument = (XmlDocument) NokogiriService.XML_DOCUMENT_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::Document"));
+                xmlDocument.setDocumentNode(runtime, (Document) node);
+                return xmlDocument;
+            case Node.DOCUMENT_TYPE_NODE:
+                XmlDtd xmlDtd = (XmlDtd) NokogiriService.XML_DTD_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::DTD"));
+                xmlDtd.setNode(runtime, node);
+                return xmlDtd;
+            default:
+                XmlNode xmlNode = (XmlNode) NokogiriService.XML_NODE_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::Node"));
+                xmlNode.setNode(runtime, node);
+                return xmlNode;
+        }
+    }
+    
+    public static RubyClass getNokogiriClass(Ruby ruby, String name) {
+        return NokogiriService.getNokogiriClassCache(ruby).get(name);
+    }
+
+    public static IRubyObject stringOrNil(Ruby runtime, String str) {
+        return str == null ? runtime.getNil() : convertString(runtime, str);
+    }
+
+    public static IRubyObject stringOrNil(Ruby runtime, CharSequence str) {
+        return str == null ? runtime.getNil() : convertString(runtime, str);
+    }
+
+    public static IRubyObject stringOrNil(Ruby runtime, byte[] bytes) {
+        return bytes == null ? runtime.getNil() : RubyString.newString(runtime, bytes);
+    }
+
+    public static IRubyObject stringOrBlank(Ruby runtime, String str) {
+        return str == null ? runtime.newString() : convertString(runtime, str);
+    }
+    
+    public static RubyString convertString(Ruby runtime, String str) {
+        return RubyString.newUTF8String(runtime, str);
+    }
+
+    public static RubyString convertString(Ruby runtime, CharSequence str) {
+        return RubyString.newUTF8String(runtime, str);
+    }
+
+    /**
+     * Convert <code>s</code> to a RubyString, or if s is null or
+     * empty return RubyNil.
+     */
+    public static IRubyObject nonEmptyStringOrNil(Ruby runtime, String s) {
+        if (s == null || s.length() == 0) return runtime.getNil();
+        return RubyString.newString(runtime, s);
+    }
+
+    /**
+     * Return the prefix of a qualified name like "prefix:local".
+     * Returns null if there is no prefix.
+     */
+    public static String getPrefix(String qName) {
+        if (qName == null) return null;
+
+        final int pos = qName.indexOf(':');
+        return pos > 0 ? qName.substring(0, pos) : null;
+    }
+
+    /**
+     * Return the local part of a qualified name like "prefix:local".
+     * Returns <code>qName</code> if there is no prefix.
+     */
+    public static String getLocalPart(String qName) {
+        if (qName == null) return null;
+
+        final int pos = qName.indexOf(':');
+        return pos > 0 ? qName.substring(pos + 1) : qName;
+    }
+
+    public static String getLocalNameForNamespace(String name, String defValue) {
+        String localName = getLocalPart(name);
+        return ("xmlns".equals(localName)) ? defValue : localName;
+    }
+
+    public static String rubyStringToString(IRubyObject str) {
+        if (str.isNil()) return null;
+        return str.convertToString().decodeString();
+    }
+
+    public static String rubyStringToString(RubyString str) {
+        return str.decodeString(); // if encoding UTF-8 will decode UTF-8
+    }
+
+    public static ByteArrayInputStream stringBytesToStream(final IRubyObject str) {
+        if (str instanceof RubyString || str.respondsTo("to_str")) {
+            final ByteList bytes = str.convertToString().getByteList();
+            return new ByteArrayInputStream(bytes.unsafeBytes(), bytes.begin(), bytes.length());
+        }
+        return null;
+    }
+
+    public static String getNodeCompletePath(Node node) {
+
+        Node cur, tmp, next;
+
+        String buffer = "";
+
+        cur = node;
+
+        do {
+            String name = "";
+            String sep = "?";
+            int occur = 0;
+            boolean generic = false;
+
+            if(cur.getNodeType() == Node.DOCUMENT_NODE) {
+                if(buffer.startsWith("/")) break;
+
+                sep = "/";
+                next = null;
+            } else if(cur.getNodeType() == Node.ELEMENT_NODE) {
+                generic = false;
+                sep = "/";
+
+                name = cur.getLocalName();
+                if (name == null) name = cur.getNodeName();
+                if(cur.getNamespaceURI() != null) {
+                    if(cur.getPrefix() != null) {
+                        name = cur.getPrefix() + ":" + name;
+                    } else {
+                        generic = true;
+                        name = "*";
+                    }
+                }
+
+                next = cur.getParentNode();
+
+                /*
+                 * Thumbler index computation
+                 */
+
+                tmp = cur.getPreviousSibling();
+
+                while(tmp != null) {
+                    if((tmp.getNodeType() == Node.ELEMENT_NODE) &&
+                       (generic || fullNamesMatch(tmp, cur))) {
+                        occur++;
+                    }
+                    tmp = tmp.getPreviousSibling();
+                }
+
+                if(occur == 0) {
+                    tmp = cur.getNextSibling();
+
+                    while(tmp != null && occur == 0) {
+                        if((tmp.getNodeType() == Node.ELEMENT_NODE) &&
+                            (generic || fullNamesMatch(tmp,cur))) {
+                            occur++;
+                        }
+                        tmp = tmp.getNextSibling();
+                    }
+
+                    if(occur != 0) occur = 1;
+
+                } else {
+                    occur++;
+                }
+            } else if(cur.getNodeType() == Node.COMMENT_NODE) {
+                sep = "/";
+                name = "comment()";
+                next = cur.getParentNode();
+
+                /*
+                 * Thumbler index computation.
+                 */
+
+                tmp = cur.getPreviousSibling();
+
+                while(tmp != null) {
+                    if(tmp.getNodeType() == Node.COMMENT_NODE) {
+                        occur++;
+                    }
+                    tmp = tmp.getPreviousSibling();
+                }
+
+                if(occur == 0) {
+                    tmp = cur.getNextSibling();
+                    while(tmp != null && occur == 0) {
+                        if(tmp.getNodeType() == Node.COMMENT_NODE) {
+                            occur++;
+                        }
+                        tmp = tmp.getNextSibling();
+                    }
+                    if(occur != 0) occur = 1;
+                } else {
+                    occur = 1;
+                }
+
+            } else if(cur.getNodeType() == Node.TEXT_NODE ||
+                cur.getNodeType() == Node.CDATA_SECTION_NODE) {
+                    // I'm here. gist:129
+                    // http://gist.github.com/144923
+
+                sep = "/";
+                name = "text()";
+                next = cur.getParentNode();
+
+                /*
+                 * Thumbler index computation.
+                 */
+
+                tmp = cur.getPreviousSibling();
+                while(tmp != null) {
+                    if(tmp.getNodeType() == Node.TEXT_NODE ||
+                            tmp.getNodeType() == Node.CDATA_SECTION_NODE) {
+                        occur++;
+                    }
+                    tmp = tmp.getPreviousSibling();
+                }
+
+                if(occur == 0) {
+                    tmp = cur.getNextSibling();
+
+                    while(tmp != null && occur == 0) {
+                        if(tmp.getNodeType() == Node.TEXT_NODE ||
+                                tmp.getNodeType() == Node.CDATA_SECTION_NODE) {
+                            occur++;
+                        }
+                        tmp = tmp.getNextSibling();
+                    }
+                } else {
+                    occur++;
+                }
+
+            } else if(cur.getNodeType() == Node.PROCESSING_INSTRUCTION_NODE) {
+                sep = "/";
+                name = "processing-instruction('"+cur.getLocalName()+"')";
+                next = cur.getParentNode();
+
+                /*
+                 * Thumbler index computation.
+                 */
+
+                tmp = cur.getParentNode();
+
+                while(tmp != null) {
+                    if(tmp.getNodeType() == Node.PROCESSING_INSTRUCTION_NODE &&
+                            tmp.getLocalName().equals(cur.getLocalName())) {
+                        occur++;
+                    }
+                    tmp = tmp.getPreviousSibling();
+                }
+
+                if(occur == 0) {
+                    tmp = cur.getNextSibling();
+
+                    while(tmp != null && occur == 0) {
+                        if(tmp.getNodeType() == Node.PROCESSING_INSTRUCTION_NODE &&
+                                tmp.getLocalName().equals(cur.getLocalName())){
+                            occur++;
+                        }
+                        tmp = tmp.getNextSibling();
+                    }
+
+                    if(occur != 0) {
+                        occur = 1;
+                    }
+
+                } else {
+                    occur++;
+                }
+
+            } else if(cur.getNodeType() == Node.ATTRIBUTE_NODE) {
+                sep = "/@";
+                name = cur.getLocalName();
+
+                if(cur.getNamespaceURI() != null) {
+                    if(cur.getPrefix() != null) {
+                        name = cur.getPrefix() + ":" + name;
+                    }
+                }
+
+                next = ((Attr) cur).getOwnerElement();
+
+            } else {
+                next = cur.getParentNode();
+            }
+
+            if(occur == 0){
+                buffer = sep+name+buffer;
+            } else {
+                buffer = sep+name+"["+occur+"]"+buffer;
+            }
+
+            cur = next;
+
+        } while(cur != null);
+
+        return buffer;
+    }
+
+    static boolean compareTwoNodes(Node m, Node n) {
+        return nodesAreEqual(m.getLocalName(), n.getLocalName()) &&
+               nodesAreEqual(m.getPrefix(), n.getPrefix());
+    }
+
+    private static boolean nodesAreEqual(Object a, Object b) {
+        return (((a == null) && (b == null)) ||
+                ((a != null) && (b != null) && (b.equals(a))));
+    }
+
+    private static boolean fullNamesMatch(Node a, Node b) {
+        return a.getNodeName().equals(b.getNodeName());
+    }
+
+    private static final Pattern encoded_pattern = Pattern.compile("&amp;|&gt;|&lt;|&#13;");
+    private static final String[] encoded = {"&amp;", "&gt;", "&lt;", "&#13;"};
+    private static final Pattern decoded_pattern = Pattern.compile("&|>|<|\r");
+    private static final String[] decoded = {"&", ">", "<", "\r"};
+
+    private static StringBuffer convert(Pattern ptn, CharSequence input, String[] oldChars, String[] newChars)  {
+        Matcher matcher = ptn.matcher(input);
+        boolean result = matcher.find();
+        StringBuffer sb = new StringBuffer(input.length() + 8);
+        while (result) {
+            String matched = matcher.group();
+            String replacement = "";
+            for (int i=0; i<oldChars.length; i++) {
+                if (matched.contains(oldChars[i])) {
+                    replacement = matched.replace(oldChars[i], newChars[i]);
+                    break;
+                }
+            }
+            matcher.appendReplacement(sb, replacement);
+            result = matcher.find();
+        }
+        matcher.appendTail(sb);
+        return sb;
+    }
+
+    public static CharSequence encodeJavaString(CharSequence str) {
+        return convert(decoded_pattern, str, decoded, encoded);
+    }
+
+    public static CharSequence decodeJavaString(CharSequence str) {
+        return convert(encoded_pattern, str, encoded, decoded);
+    }
+
+    public static final String XMLNS_URI = "http://www.w3.org/2000/xmlns/";
+    public static boolean isNamespace(Node node) {
+        return (XMLNS_URI.equals(node.getNamespaceURI()) || isNamespace(node.getNodeName()));
+    }
+
+    public static boolean isNamespace(String nodeName) {
+        return (nodeName.startsWith("xmlns"));
+    }
+
+    public static boolean isNonDefaultNamespace(Node node) {
+        return (isNamespace(node) && ! "xmlns".equals(node.getNodeName()));
+    }
+
+    public static boolean isXmlBase(String attrName) {
+        return "xml:base".equals(attrName) || "xlink:href".equals(attrName);
+    }
+
+    public static boolean isBlank(IRubyObject obj) {
+        if ( !(obj instanceof XmlText) ) return false;
+
+        CharSequence content = ((XmlNode) obj).getContentImpl();
+        return content == null || isBlank(content);
+    }
+
+    public static boolean isBlank(CharSequence str) {
+        int len = str.length(); int beg = 0;
+        while ((beg < len) && (str.charAt(beg) <= ' ')) beg++;
+        return beg == len;
+    }
+
+    public static boolean isBlank(String str) {
+        return str.isEmpty() || isBlank((CharSequence) str);
+    }
+
+    public static boolean isNullOrEmpty(String str) {
+        return str == null || str.isEmpty();
+    }
+
+    public static CharSequence canonicalizeWhitespace(CharSequence str) {
+        final int len = str.length();
+        StringBuilder sb = new StringBuilder(len);
+        boolean newline_added = false;
+        for ( int i = 0; i < len; i++ ) {
+            char c = str.charAt(i);
+            if ( c == '\n' ) {
+                if ( ! newline_added ) {
+                    sb.append(c); newline_added = true;
+                }
+            } else {
+                sb.append(c);
+            }
+        }
+        return sb;
+    }
+
+    public static String newQName(String newPrefix, Node node) {
+        String tagName = getLocalPart(node.getNodeName());
+        if (newPrefix == null) return tagName;
+        return newPrefix + ':' + tagName;
+    }
+
+    public static IRubyObject[] nodeListToRubyArray(Ruby runtime, NodeList nodes) {
+        IRubyObject[] array = new IRubyObject[nodes.getLength()];
+        for (int i = 0; i < nodes.getLength(); i++) {
+            array[i] = NokogiriHelpers.getCachedNodeOrCreate(runtime, nodes.item(i));
+        }
+        return array;
+    }
+
+    public static IRubyObject[] nodeListToArray(Ruby ruby, List<Node> nodes) {
+        IRubyObject[] result = new IRubyObject[nodes.size()];
+        for (int i = 0; i < result.length; i++) {
+            result[i] = NokogiriHelpers.getCachedNodeOrCreate(ruby, nodes.get(i));
+        }
+        return result;
+    }
+
+    public static RubyArray nodeArrayToRubyArray(Ruby ruby, Node[] nodes) {
+        RubyArray n = RubyArray.newArray(ruby, nodes.length);
+        for (int i = 0; i < nodes.length; i++) {
+            n.append(NokogiriHelpers.getCachedNodeOrCreate(ruby, nodes[i]));
+        }
+        return n;
+    }
+
+    public static String getValidEncodingOrNull(IRubyObject encoding) {
+        if (encoding.isNil()) return null; // charsetNames does not like contains(null)
+        String enc = rubyStringToString(encoding.convertToString());
+        if (CharsetNames.contains(enc)) return enc;
+        return null;
+    }
+
+    public static String getValidEncoding(IRubyObject encoding) {
+        String validEncoding = getValidEncodingOrNull(encoding);
+        if (validEncoding != null) return validEncoding;
+        return Charset.defaultCharset().name();
+    }
+
+    private static final Set<String> CharsetNames = Charset.availableCharsets().keySet();
+
+    public static String adjustSystemIdIfNecessary(String currentDir, String scriptFileName, String baseURI, String systemId) {
+        if (systemId == null) return systemId;
+        File file = new File(systemId);
+        if (file.isAbsolute()) return systemId;
+        String path = resolveSystemId(baseURI, systemId);
+        if (path != null) return path;
+        path = resolveSystemId(currentDir, systemId);
+        if (path != null) return path;
+        return resolveSystemId(scriptFileName, systemId);
+    }
+
+    private static String resolveSystemId(String baseName, String systemId) {
+        if (baseName == null || baseName.length() < 1) return null;
+        String parentName;
+        baseName = baseName.replace("%20", " ");
+        File base = new File(baseName);
+        if (base.isDirectory()) parentName = baseName;
+        else parentName = base.getParent();
+        if (parentName == null) return null;
+        if (parentName.toLowerCase().startsWith("file:")) parentName = parentName.substring("file:".length());
+        File dtdFile = new File(parentName + "/" + systemId);
+        if (dtdFile.exists()) return dtdFile.getPath();
+        return null;
+    }
+
+    private static final Charset UTF8 = Charset.forName("UTF-8");
+
+    public static boolean isUTF8(String encoding) {
+        if (encoding == null) return true; // no need to convert encoding
+
+        if ("UTF-8".equals(encoding)) return true;
+        return UTF8.aliases().contains(encoding);
+    }
+
+    public static ByteBuffer convertEncoding(Charset output_charset, CharSequence input_string) {
+        return output_charset.encode(CharBuffer.wrap(input_string)); // does replace implicitly on un-mappable characters
+    }
+
+    public static CharSequence convertEncodingByNKFIfNecessary(ThreadContext context, XmlDocument doc, CharSequence str) {
+        if (!(doc instanceof HtmlDocument)) return str;
+        String parsed_encoding = ((HtmlDocument)doc).getPraedEncoding();
+        if (parsed_encoding == null) return str;
+        String ruby_encoding = rubyStringToString(doc.getEncoding());
+        if (ruby_encoding == null) return str;
+        Charset encoding = Charset.forName(ruby_encoding);
+        if (Charset.forName(parsed_encoding).compareTo(encoding) == 0) return str;
+        if (str.length() == 0) return str; // no need to convert
+        return NokogiriHelpers.nkf(context, encoding, str);
+    }
+
+    private static final ByteList _Sw = new ByteList(new byte[] { '-','S','w' }, false);
+    private static final ByteList _Jw = new ByteList(new byte[] { '-','J','w' }, false);
+    private static final ByteList _Ew = new ByteList(new byte[] { '-','E','w' }, false);
+    private static final ByteList _Ww = new ByteList(new byte[] { '-','W','w' }, false);
+
+    // This method is used from HTML documents. HTML meta tag with encoding specification
+    // might appear after non-ascii characters are used. For example, a title tag before
+    // a meta tag. In such a case, Xerces encodes characters in UTF-8 without seeing meta tag.
+    // Nokogiri uses NKF library to convert characters correct encoding. This means the method
+    // works only for JIS/Shift_JIS/EUC-JP.
+    private static CharSequence nkf(ThreadContext context, Charset encoding, CharSequence str) {
+        final Ruby runtime = context.getRuntime();
+        final ByteList opt;
+        if (NokogiriHelpers.Shift_JIS.compareTo(encoding) == 0) opt = _Sw;
+        else if (NokogiriHelpers.ISO_2022_JP.compareTo(encoding) == 0) opt = _Jw;
+        else if (NokogiriHelpers.EUC_JP.compareTo(encoding) == 0) opt = _Ew;
+        else opt = _Ww; // should not come here. should be treated before this method.
+
+        Class nkfClass;
+        try {
+            // JRuby 1.7 and later
+            nkfClass = runtime.getClassLoader().loadClass("org.jruby.ext.nkf.RubyNKF");
+        } catch (ClassNotFoundException e1) {
+            return str;
+        }
+        Method nkf_method;
+        try {
+            nkf_method = nkfClass.getMethod("nkf", ThreadContext.class, IRubyObject.class, IRubyObject.class, IRubyObject.class);
+            RubyString r_str = 
+                (RubyString)nkf_method.invoke(null, context, null, runtime.newString(opt), runtime.newString(str.toString()));
+            return NokogiriHelpers.rubyStringToString(r_str);
+        } catch (SecurityException e) {
+            return str;
+        } catch (NoSuchMethodException e) {
+            return str;
+        } catch (IllegalArgumentException e) {
+            return str;
+        } catch (IllegalAccessException e) {
+            return str;
+        } catch (InvocationTargetException e) {
+            return str;
+        }
+    }
+
+    private static final Charset Shift_JIS = Charset.forName("Shift_JIS");
+    private static final Charset ISO_2022_JP = Charset.forName("ISO-2022-JP"); // JIS
+    private static final Charset EUC_JP = Charset.forName("EUC-JP");
+
+    public static boolean shouldEncode(Node text) {
+        final Boolean encoded = (Boolean) text.getUserData(NokogiriHelpers.ENCODED_STRING);
+        return encoded == null || ! encoded;
+    }
+
+    public static boolean shouldDecode(Node text) {
+      return !shouldEncode(text);
+    }
+
+    public static NokogiriNamespaceCache getNamespaceCache(Node node) {
+        XmlDocument xmlDoc = (XmlDocument) getCachedNode(node.getOwnerDocument());
+        return xmlDoc.getNamespaceCache();
+    }
+
+    public static Node renameNode(Node node, String namespaceURI, String qualifiedName) throws DOMException {
+        Document doc = node.getOwnerDocument();
+        NokogiriNamespaceCache nsCache = getNamespaceCache(node);
+        Node result = doc.renameNode(node, namespaceURI, qualifiedName);
+        if (result != node) {
+            nsCache.replaceNode(node, result);
+        }
+        return result;
+    }
+}