nokogiri 1.5.0.beta.1 → 1.5.0.beta.2

data/ext/java/nokogiri/internals/NokogiriErrorHandler.java

@@ -0,0 +1,42 @@
+package nokogiri.internals;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import nokogiri.XmlSyntaxError;
+
+import org.apache.xerces.xni.parser.XMLErrorHandler;
+import org.jruby.Ruby;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.xml.sax.ErrorHandler;
+
+/**
+ *
+ * @author sergio
+ */
+public abstract class NokogiriErrorHandler
+    implements ErrorHandler, XMLErrorHandler {
+
+    protected List<Exception> errors;
+
+    public NokogiriErrorHandler() {
+        this.errors = new ArrayList<Exception>();
+    }
+
+    void addError(Exception e) {
+        errors.add(e);
+    }
+
+    public List<Exception> getErrors() { return this.errors; }
+
+    public List<IRubyObject> getErrorsReadyForRuby(ThreadContext context){
+        Ruby ruby = context.getRuntime();
+        List<IRubyObject> res = new ArrayList<IRubyObject>();
+        for(int i = 0; i < this.errors.size(); i++) {
+            res.add(new XmlSyntaxError(ruby, this.errors.get(i)));
+        }
+        return res;
+    }
+
+}

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

@@ -0,0 +1,251 @@
+package nokogiri.internals;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import static nokogiri.internals.NokogiriHelpers.getLocalPart;
+import static nokogiri.internals.NokogiriHelpers.getPrefix;
+import static nokogiri.internals.NokogiriHelpers.isNamespace;
+import static nokogiri.internals.NokogiriHelpers.stringOrNil;
+
+import java.util.logging.Logger;
+
+import nokogiri.XmlSyntaxError;
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyObject;
+import org.jruby.javasupport.util.RuntimeHelpers;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.xml.sax.Attributes;
+import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
+import org.xml.sax.ext.DefaultHandler2;
+
+/**
+ *
+ * @author sergio
+ */
+public class NokogiriHandler extends DefaultHandler2
+    implements XmlDeclHandler {
+
+    private static Logger LOGGER = Logger.getLogger(NokogiriHandler.class.getName());
+
+    boolean inCDATA = false;
+
+    private Ruby ruby;
+    private RubyClass attrClass;
+    private IRubyObject object;
+    private boolean namespaceDefined = false;
+
+    /**
+     * Stores parse errors with the most-recent error last.
+     *
+     * TODO: should these be stored in the document 'errors' array?
+     * Currently only string messages are stored there.
+     */
+    private LinkedList<XmlSyntaxError> errors =
+        new LinkedList<XmlSyntaxError>();
+
+    public NokogiriHandler(Ruby ruby, IRubyObject object) {
+        this.ruby = ruby;
+        this.attrClass = (RubyClass) ruby.getClassFromPath(
+            "Nokogiri::XML::SAX::Parser::Attribute");
+        this.object = object;
+    }
+
+    @Override
+    public void startDocument() throws SAXException {
+        call("start_document");
+    }
+
+    public void xmlDecl(String version, String encoding, String standalone) {
+        call("xmldecl", stringOrNil(ruby, version),
+             stringOrNil(ruby, encoding),
+             stringOrNil(ruby, standalone));
+    }
+
+    @Override
+    public void endDocument() throws SAXException {
+        call("end_document");
+    }
+
+    /*
+     * This has to call either "start_element" or
+     * "start_element_namespace" depending on whether there are any
+     * namespace attributes.
+     *
+     * Attributes that define namespaces are passed in a separate
+     * array of of <code>[:prefix, :uri]</code> arrays and are not
+     * passed with the other attributes.
+     */
+    @Override
+    public void startElement(String uri, String localName, String qName,
+                             Attributes attrs) throws SAXException {
+        // for attributes other than namespace attrs
+        RubyArray rubyAttr = RubyArray.newArray(ruby);
+        // for namespace defining attributes
+        RubyArray rubyNSAttr = RubyArray.newArray(ruby);
+
+        ThreadContext context = ruby.getCurrentContext();
+        boolean fromFragmentHandler = false; // isFromFragmentHandler();
+        
+        for (int i = 0; i < attrs.getLength(); i++) {
+            String u = attrs.getURI(i);
+            String qn = attrs.getQName(i);
+            String ln = attrs.getLocalName(i);
+            String val = attrs.getValue(i);
+            String pre;
+
+            pre = getPrefix(qn);
+            if (ln == null || ln.equals("")) 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 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);
+            } else {
+                IRubyObject[] args = new IRubyObject[4];
+                args[0] = stringOrNil(ruby, ln);
+                args[1] = stringOrNil(ruby, pre);
+                args[2] = stringOrNil(ruby, u);
+                args[3] = stringOrNil(ruby, val);
+
+                IRubyObject attr =
+                    RuntimeHelpers.invoke(context, attrClass, "new", args);
+                rubyAttr.add(attr);
+            }
+        }
+
+        if (localName == null || localName.equals(""))
+            localName = getLocalPart(qName);
+        call("start_element_namespace",
+             stringOrNil(ruby, localName),
+             rubyAttr,
+             stringOrNil(ruby, getPrefix(qName)),
+             stringOrNil(ruby, uri),
+             rubyNSAttr);
+    }
+    
+    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;
+    }
+
+    @Override
+    public void endElement(String uri, String localName, String qName) throws SAXException {
+        call("end_element_namespace",
+             stringOrNil(ruby, localName),
+             stringOrNil(ruby, getPrefix(qName)),
+             stringOrNil(ruby, uri));
+    }
+
+    @Override
+    public void characters(char[] ch, int start, int length) throws SAXException {
+        String target = inCDATA ? "cdata_block" : "characters";
+        call(target, ruby.newString(new String(ch, start, length)));
+    }
+
+    @Override
+    public void comment(char[] ch, int start, int length) throws SAXException {
+        call("comment", ruby.newString(new String(ch, start, length)));
+    }
+
+    @Override
+    public void startCDATA() throws SAXException {
+        inCDATA = true;
+    }
+
+    @Override
+    public void endCDATA() throws SAXException {
+        inCDATA = false;
+    }
+
+    @Override
+    public void error(SAXParseException saxpe) {
+        addError(XmlSyntaxError.createError(ruby, saxpe));
+        call("error", ruby.newString(saxpe.getMessage()));
+    }
+
+    @Override
+    public void fatalError(SAXParseException saxpe) throws SAXException
+    {
+        addError(XmlSyntaxError.createFatalError(ruby, saxpe));
+        call("error", ruby.newString(saxpe.getMessage()));
+    }
+
+    @Override
+    public void warning(SAXParseException saxpe) {
+        //System.out.println("warning: " + saxpe);
+        call("warning", ruby.newString(saxpe.getMessage()));
+    }
+
+    protected synchronized void addError(XmlSyntaxError e) {
+        errors.add(e);
+    }
+
+    public synchronized int getErrorCount() {
+        return errors.size();
+    }
+
+    public synchronized IRubyObject getLastError() {
+        return errors.getLast();
+    }
+
+    private void call(String methodName) {
+        ThreadContext context = ruby.getCurrentContext();
+        RuntimeHelpers.invoke(context, document(context), methodName);
+    }
+
+    private void call(String methodName, IRubyObject argument) {
+        ThreadContext context = ruby.getCurrentContext();
+        RuntimeHelpers.invoke(context, document(context), methodName, argument);
+    }
+
+    private void call(String methodName, IRubyObject arg1, IRubyObject arg2) {
+        ThreadContext context = ruby.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 arg0,
+                      IRubyObject arg1,
+                      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);
+    }
+
+    private IRubyObject document(ThreadContext context){
+        return RuntimeHelpers.invoke(context, this.object, "document");
+    }
+
+}

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

@@ -0,0 +1,526 @@
+package nokogiri.internals;
+
+import java.nio.ByteBuffer;
+import java.nio.charset.Charset;
+
+import nokogiri.NokogiriService;
+import nokogiri.XmlAttr;
+import nokogiri.XmlCdata;
+import nokogiri.XmlComment;
+import nokogiri.XmlDocument;
+import nokogiri.XmlElement;
+import nokogiri.XmlNamespace;
+import nokogiri.XmlNode;
+import nokogiri.XmlText;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyEncoding;
+import org.jruby.RubyHash;
+import org.jruby.RubyString;
+import org.jruby.javasupport.JavaUtil;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
+import org.w3c.dom.Attr;
+import org.w3c.dom.Document;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+/**
+ *
+ * @author serabe
+ */
+public class NokogiriHelpers {
+    public static final String CACHED_NODE = "NOKOGIRI_CACHED_NODE";
+    public static final String VALID_ROOT_NODE = "NOKOGIRI_VALIDE_ROOT_NODE";
+
+    public static XmlNode getCachedNode(Node node) {
+        return (XmlNode) node.getUserData(CACHED_NODE);
+    }
+
+    /**
+     * 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 ruby, Node node) {
+        if(node == null) return ruby.getNil();
+        if (node.getNodeType() == Node.ATTRIBUTE_NODE && isNamespace(node.getNodeName())) {
+            XmlDocument xmlDocument = (XmlDocument)node.getOwnerDocument().getUserData(CACHED_NODE);
+            XmlNamespace xmlNamespace = xmlDocument.getNamespaceCache().get(node.getNodeName(), node.getNodeName());
+            if (xmlNamespace == null) {
+                String prefix = getLocalNameForNamespace(((Attr)node).getName());
+                prefix = prefix != null ? prefix : "";
+                return xmlDocument.getNamespaceCache().put(ruby, prefix, ((Attr)node).getValue(), node, xmlDocument);
+            }
+        }
+        XmlNode xmlNode = getCachedNode(node);
+        if(xmlNode == null) {
+            xmlNode = (XmlNode)constructNode(ruby, 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 ruby, Node node) {
+        if (node == null) return ruby.getNil();
+        // this is slow; need a way to cache nokogiri classes/modules somewhere
+        switch (node.getNodeType()) {
+            case Node.ELEMENT_NODE:
+                return new XmlElement(ruby, getNokogiriClass(ruby, "Nokogiri::XML::Element"), node);
+            case Node.ATTRIBUTE_NODE:
+                return new XmlAttr(ruby, getNokogiriClass(ruby, "Nokogiri::XML::Attr"), node);
+            case Node.TEXT_NODE:
+                return new XmlText(ruby, getNokogiriClass(ruby, "Nokogiri::XML::Text"), node);
+            case Node.COMMENT_NODE:
+                return new XmlComment(ruby, getNokogiriClass(ruby, "Nokogiri::XML::Comment"), node);
+            case Node.ENTITY_NODE:
+                return new XmlNode(ruby, getNokogiriClass(ruby, "Nokogiri::XML::EntityDecl"), node);
+            case Node.CDATA_SECTION_NODE:
+                return new XmlCdata(ruby, getNokogiriClass(ruby, "Nokogiri::XML::CDATA"), node);
+            case Node.DOCUMENT_NODE:
+                return new XmlDocument(ruby, getNokogiriClass(ruby, "Nokogiri::XML::Document"), (Document) node);
+            default:
+                return new XmlNode(ruby, getNokogiriClass(ruby, "Nokogiri::XML::Node"), node);
+        }
+    }
+    
+    public static RubyClass getNokogiriClass(Ruby ruby, String name) {
+        RubyHash classCache = (RubyHash) ruby.getGlobalVariables().get(NokogiriService.nokogiriClassCacheGvarName);
+        IRubyObject rubyName = JavaUtil.convertJavaToUsableRubyObject(ruby, name);
+        return (RubyClass)classCache.fastARef(rubyName);
+    }
+
+    public static IRubyObject stringOrNil(Ruby ruby, String s) {
+        if (s == null)
+            return ruby.getNil();
+
+        return JavaUtil.convertJavaToUsableRubyObject(ruby, s);
+    }
+    
+    public static IRubyObject stringOrBlank(Ruby ruby, String s) {
+        if (s == null) return ruby.newString();
+        return ruby.newString(s);
+    }
+
+    /**
+     * Convert <code>s</code> to a RubyString, or if s is null or
+     * empty return RubyNil.
+     */
+    public static IRubyObject nonEmptyStringOrNil(Ruby ruby, String s) {
+        if (s == null || s.length() == 0)
+            return ruby.getNil();
+
+        return ruby.newString(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;
+
+        int pos = qName.indexOf(':');
+        if (pos > 0)
+            return qName.substring(0, pos);
+        else
+            return 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;
+
+        int pos = qName.indexOf(':');
+        if (pos > 0)
+            return qName.substring(pos + 1);
+        else
+            return qName;
+    }
+
+    public static String getLocalNameForNamespace(String name) {
+        String localName = getLocalPart(name);
+        return ("xmlns".equals(localName)) ? null : localName;
+    }
+
+    protected static Charset utf8 = null;
+    protected static Charset getCharsetUTF8() {
+        if (utf8 == null) {
+            utf8 = Charset.forName("UTF-8");
+        }
+
+        return utf8;
+    }
+
+    /**
+     * Converts a RubyString in to a Java String.  Assumes the
+     * RubyString is encoded as UTF-8.  This is generally the case for
+     * RubyStrings created with getRuntime().newString("java string").
+     * It also seems to be the case for strings created within Ruby
+     * where $KCODE has not been set.
+     *
+     * Note that RubyString#toString() decodes the string data as
+     * ISO-8859-1 (See org.jruby.util.ByteList.java).  This is not
+     * what you want if you have any multibyte characters in your
+     * UTF-8 string.
+     *
+     * FIXME: This really needs to be more robust in terms of
+     * detecting the encoding and properly converting to a Java
+     * String.  It's unfortunate that RubyString#toString() doesn't do
+     * this for us.
+     */
+    public static String rubyStringToString(IRubyObject str) {
+        return rubyStringToString(str.convertToString());
+    }
+
+    public static String rubyStringToString(RubyString str) {
+        ByteList byteList = str.getByteList();
+        byte[] data = byteList.unsafeBytes();
+        int offset = byteList.begin();
+        int len = byteList.length();
+        ByteBuffer buf = ByteBuffer.wrap(data, offset, len);
+        return getCharsetUTF8().decode(buf).toString();
+    }
+
+    public static String getNodeCompletePath(Node node) {
+
+        Node cur, tmp, next;
+
+        // TODO: Rename buffer to path.
+        String buffer = "";
+        String sep;
+        String name;
+
+        int occur = 0;
+        boolean generic;
+
+        cur = node;
+
+        do {
+            name = "";
+            sep = "?";
+            occur = 0;
+            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;
+    }
+
+    protected static boolean compareTwoNodes(Node m, Node n) {
+        return nodesAreEqual(m.getLocalName(), n.getLocalName()) &&
+               nodesAreEqual(m.getPrefix(), n.getPrefix());
+    }
+
+    protected static boolean fullNamesMatch(Node a, Node b) {
+        return a.getNodeName().equals(b.getNodeName());
+        //return getFullName(a).equals(getFullName(b));
+    }
+
+    protected static String getFullName(Node n) {
+        String lname = n.getLocalName();
+        String prefix = n.getPrefix();
+        if (lname != null) {
+            if (prefix != null)
+                return prefix + ":" + lname;
+            else
+                return lname;
+        } else {
+            return n.getNodeName();
+        }
+    }
+
+    private static boolean nodesAreEqual(Object a, Object b) {
+      return (((a == null) && (a == null)) ||
+                (a != null) && (b != null) &&
+                (b.equals(a)));
+    }
+
+    public static String encodeJavaString(String s) {
+
+        // From entities.c
+        s = s.replaceAll("&", "&amp;");
+        s = s.replaceAll("<", "&lt;");
+        s = s.replaceAll(">", "&gt;");
+//        s = s.replaceAll("\"", "&quot;");
+        return s.replaceAll("\r", "&#13;");
+    }
+    
+    public static String decodeJavaString(String s) {
+        s = s.replaceAll("&amp;", "&");
+        s = s.replaceAll("&lt;", "<");
+        s = s.replaceAll("&gt;", ">");
+        return s.replaceAll("&#13;", "\r");
+    }
+    
+    public static boolean isXmlEscaped(String s) {
+        if (s == null) return true;
+        if (s.contains("<") || s.contains(">") || s.contains("\r")) return false;
+        if (s.contains("&") && !s.contains("&amp;")) return false;
+        return true;
+    }
+
+    public static String getNodeName(Node node) {
+        if(node == null) { System.out.println("node is null"); return ""; }
+        String name = node.getNodeName();
+        if(name == null) { System.out.println("name is null"); return ""; }
+        if(name.equals("#document")) {
+            return "document";
+        } else if(name.equals("#text")) {
+            return "text";
+        } else {
+            name = getLocalPart(name);
+            return (name == null) ? "" : name;
+        }
+    }
+
+    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.equals("xmlns") || 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 String newQName(String newPrefix, Node node) {
+        if(newPrefix == null) {
+            return node.getLocalName();
+        } else {
+            return newPrefix + ":" + node.getLocalName();
+        }
+    }
+
+    public static RubyArray nodeListToRubyArray(Ruby ruby, NodeList nodes) {
+        RubyArray n = RubyArray.newArray(ruby, nodes.getLength());
+        for(int i = 0; i < nodes.getLength(); i++) {
+            n.append(NokogiriHelpers.getCachedNodeOrCreate(ruby, nodes.item(i)));
+        }
+        return n;
+    }
+    
+    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 RubyArray namedNodeMapToRubyArray(Ruby ruby, NamedNodeMap map) {
+        RubyArray n = RubyArray.newArray(ruby, map.getLength());
+        for(int i = 0; i < map.getLength(); i++) {
+            n.append(NokogiriHelpers.getCachedNodeOrCreate(ruby, map.item(i)));
+        }
+        return n;
+    }
+    
+    public static String guessEncoding(Ruby ruby) {
+        String name = null;
+        if (name == null) name = System.getProperty("file.encoding");
+        if (name == null) name = "UTF-8";
+        return name;
+    }
+}