nokogiri 1.6.1-java → 1.6.2-java

data/ext/java/nokogiri/XmlReader.java

@@ -244,7 +244,7 @@ public class XmlReader extends RubyObject {
           // use the default options RECOVER | NONET
           options = new ParserContext.Options(2048 | 1);
         }
-        IRubyObject stringIO = NokogiriService.nokogiriClassCache.get("StringIO").newInstance(context, args[0], Block.NULL_BLOCK);
+        IRubyObject stringIO = NokogiriService.getNokogiriClassCache(context.getRuntime()).get("StringIO").newInstance(context, args[0], Block.NULL_BLOCK);
         InputStream in = new UncloseableInputStream(new IOInputStream(stringIO));
         reader.setInput(context, in, url, options);
         return reader;

data/ext/java/nokogiri/XmlSaxParserContext.java

@@ -75,11 +75,14 @@ public class XmlSaxParserContext extends ParserContext {
         "http://xml.org/sax/features/namespace-prefixes";
     protected static final String FEATURE_LOAD_EXTERNAL_DTD =
         "http://apache.org/xml/features/nonvalidating/load-external-dtd";
+    protected static final String FEATURE_CONTINUE_AFTER_FATAL_ERROR =
+        "http://apache.org/xml/features/continue-after-fatal-error";
 
     protected AbstractSAXParser parser;
 
     protected NokogiriHandler handler = null;
     private IRubyObject replaceEntities;
+    private IRubyObject recovery;
 
     public XmlSaxParserContext(final Ruby ruby, RubyClass rubyClass) {
         super(ruby, rubyClass);
@@ -87,6 +90,7 @@ public class XmlSaxParserContext extends ParserContext {
         
     protected void initialize(Ruby runtime) {
         replaceEntities = runtime.getTrue();
+        recovery = runtime.getFalse();
         try {
             parser = createParser();
         } catch (SAXException se) {
@@ -199,6 +203,13 @@ public class XmlSaxParserContext extends ParserContext {
                             IRubyObject handlerRuby,
                             NokogiriHandler handler) {
         ((XmlSaxParser) parser).setXmlDeclHandler(handler);
+        if(recovery.isTrue()) {
+          try {
+            ((XmlSaxParser) parser).setFeature(FEATURE_CONTINUE_AFTER_FATAL_ERROR, true);
+          } catch(Exception e) {
+            throw RaiseException.createNativeRaiseException(context.getRuntime(), e);
+          }
+        }
     }
 
     protected void postParse(ThreadContext context,
@@ -290,6 +301,28 @@ public class XmlSaxParserContext extends ParserContext {
         return replaceEntities;
     }
 
+    /**
+     * Can take a boolean assignment.
+     *
+     * @param context
+     * @param value
+     * @return
+     */
+    @JRubyMethod(name = "recovery=")
+    public IRubyObject set_recovery(ThreadContext context,
+                                            IRubyObject value) {
+        if (!value.isTrue()) recovery = context.getRuntime().getFalse();
+        else recovery = context.getRuntime().getTrue();
+
+        return this;
+    }
+
+    @JRubyMethod(name="recovery")
+    public IRubyObject get_recovery(ThreadContext context) {
+        return recovery;
+    }
+
+
 
     /**
      * If the handler's document is a FragmentHandler, attempt to trim

data/ext/java/nokogiri/XmlSchema.java

@@ -32,8 +32,8 @@
 
 package nokogiri;
 
-import static nokogiri.internals.NokogiriHelpers.getNokogiriClass;
 import static nokogiri.internals.NokogiriHelpers.adjustSystemIdIfNecessary;
+import static nokogiri.internals.NokogiriHelpers.getNokogiriClass;
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -48,6 +48,7 @@ import javax.xml.validation.Schema;
 import javax.xml.validation.SchemaFactory;
 import javax.xml.validation.Validator;
 
+import nokogiri.internals.IgnoreSchemaErrorsErrorHandler;
 import nokogiri.internals.SchemaErrorHandler;
 import nokogiri.internals.XmlDomParserContext;
 
@@ -95,7 +96,8 @@ public class XmlSchema extends RubyObject {
     private Schema getSchema(Source source, String currentDir, String scriptFileName) throws SAXException {
         SchemaFactory schemaFactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
         SchemaResourceResolver resourceResolver = new SchemaResourceResolver(currentDir, scriptFileName, null);
-        schemaFactory.setResourceResolver(resourceResolver); 
+        schemaFactory.setResourceResolver(resourceResolver);
+        schemaFactory.setErrorHandler(new IgnoreSchemaErrorsErrorHandler());
         return schemaFactory.newSchema(source);
     }
     

data/ext/java/nokogiri/XmlXpathContext.java

@@ -1,7 +1,7 @@
 /**
  * (The MIT License)
  *
- * Copyright (c) 2008 - 2012:
+ * Copyright (c) 2008 - 2014:
  *
  * * {Aaron Patterson}[http://tenderlovemaking.com]
  * * {Mike Dalessio}[http://mike.daless.io]
@@ -34,13 +34,11 @@ package nokogiri;
 
 import static nokogiri.internals.NokogiriHelpers.getNokogiriClass;
 
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
 import java.util.Set;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 
-import javax.xml.xpath.XPath;
-import javax.xml.xpath.XPathConstants;
-import javax.xml.xpath.XPathExpression;
+import javax.xml.transform.TransformerException;
 import javax.xml.xpath.XPathExpressionException;
 import javax.xml.xpath.XPathFactory;
 
@@ -49,40 +47,82 @@ import nokogiri.internals.NokogiriXPathFunctionResolver;
 import nokogiri.internals.NokogiriXPathVariableResolver;
 
 import org.jruby.Ruby;
-import org.jruby.RubyBoolean;
 import org.jruby.RubyClass;
 import org.jruby.RubyException;
-import org.jruby.RubyFloat;
 import org.jruby.RubyObject;
-import org.jruby.RubyString;
 import org.jruby.anno.JRubyClass;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.exceptions.RaiseException;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
+import org.w3c.dom.Node;
 import org.w3c.dom.NodeList;
 
+import com.sun.org.apache.xml.internal.dtm.DTM;
+import com.sun.org.apache.xml.internal.utils.PrefixResolver;
+import com.sun.org.apache.xpath.internal.XPathContext;
+import com.sun.org.apache.xpath.internal.jaxp.JAXPExtensionsProvider;
+import com.sun.org.apache.xpath.internal.jaxp.JAXPPrefixResolver;
+import com.sun.org.apache.xpath.internal.jaxp.JAXPVariableStack;
+import com.sun.org.apache.xpath.internal.objects.XObject;
+
 /**
  * Class for Nokogiri::XML::XpathContext
  *
  * @author sergio
  * @author Yoko Harada <yokolet@gmail.com>
+ * @author John Shahid <jvshahid@gmail.com>
  */
 @JRubyClass(name="Nokogiri::XML::XPathContext")
 public class XmlXpathContext extends RubyObject {
+    public final static String XPATH_CONTEXT = "CACHCED_XPATH_CONTEXT";
+
     private XmlNode context;
-    private XPath xpath;
-    
+    private final NokogiriXPathFunctionResolver functionResolver;
+    private final NokogiriXPathVariableResolver variableResolver;
+    private PrefixResolver prefixResolver;
+    private XPathContext xpathSupport = null;
+    private NokogiriNamespaceContext nsContext;
+
     public XmlXpathContext(Ruby ruby, RubyClass rubyClass) {
         super(ruby, rubyClass);
+        functionResolver = NokogiriXPathFunctionResolver.create(ruby.getCurrentContext().nil);
+        variableResolver = NokogiriXPathVariableResolver.create();
     }
-    
-    public void setNode(XmlNode node) {
+
+    private void setNode(XmlNode node) throws IllegalArgumentException, ClassNotFoundException, InstantiationException, IllegalAccessException, InvocationTargetException {
+        Node doc = node.getNode().getOwnerDocument();
+        if (doc == null) {
+            doc = node.getNode();
+        }
+        xpathSupport = (XPathContext) doc.getUserData(XPATH_CONTEXT);
+
+        if (xpathSupport == null) {
+            JAXPExtensionsProvider jep = getProviderInstance();
+            xpathSupport = new XPathContext(jep);
+            xpathSupport.setVarStack(new JAXPVariableStack(variableResolver));
+            doc.setUserData(XPATH_CONTEXT, xpathSupport, null);
+        }
+
         context = node;
-        xpath.setNamespaceContext(NokogiriNamespaceContext.create());
-        xpath.setXPathVariableResolver(NokogiriXPathVariableResolver.create());
+        nsContext = NokogiriNamespaceContext.create();
+        prefixResolver = new JAXPPrefixResolver(nsContext);
+    }
+
+    private JAXPExtensionsProvider getProviderInstance() throws ClassNotFoundException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException {
+        Class<?> clazz = Class.forName("com.sun.org.apache.xpath.internal.jaxp.JAXPExtensionsProvider");
+        Constructor[] constructors = clazz.getDeclaredConstructors();
+        for (int i = 0; i < constructors.length; i++) {
+            Class[] parameterTypes = constructors[i].getParameterTypes();
+            if (parameterTypes.length == 2) {
+                return (JAXPExtensionsProvider) constructors[i].newInstance(functionResolver, false);
+            } else if (parameterTypes.length == 1) {
+                return (JAXPExtensionsProvider) constructors[i].newInstance(functionResolver);
+            }
+        }
+        return null;
     }
-    
+
     /**
      * Create and return a copy of this object.
      *
@@ -97,83 +137,86 @@ public class XmlXpathContext extends RubyObject {
     public static IRubyObject rbNew(ThreadContext thread_context, IRubyObject klazz, IRubyObject node) {
         XmlNode xmlNode = (XmlNode)node;
         XmlXpathContext xmlXpathContext = (XmlXpathContext) NokogiriService.XML_XPATHCONTEXT_ALLOCATOR.allocate(thread_context.getRuntime(), (RubyClass)klazz);
-        xmlXpathContext.xpath = XPathFactory.newInstance().newXPath();
-        xmlXpathContext.setNode(xmlNode);
+        XPathFactory.newInstance().newXPath();
+        try {
+            xmlXpathContext.setNode(xmlNode);
+        } catch (IllegalArgumentException e) {
+            throw thread_context.getRuntime().newRuntimeError(e.getMessage());
+        } catch (ClassNotFoundException e) {
+            throw thread_context.getRuntime().newRuntimeError(e.getMessage());
+        } catch (InstantiationException e) {
+            throw thread_context.getRuntime().newRuntimeError(e.getMessage());
+        } catch (IllegalAccessException e) {
+            throw thread_context.getRuntime().newRuntimeError(e.getMessage());
+        } catch (InvocationTargetException e) {
+            throw thread_context.getRuntime().newRuntimeError(e.getMessage());
+        }
         return xmlXpathContext;
     }
 
     @JRubyMethod
     public IRubyObject evaluate(ThreadContext thread_context, IRubyObject expr, IRubyObject handler) {
+        functionResolver.setHandler(handler);
         String src = (String) expr.toJava(String.class);
-        try {
-            if(!handler.isNil()) {
-            	if (!isContainsPrefix(src)) {
-                    Set<String> methodNames = handler.getMetaClass().getMethods().keySet();
-                    for (String name : methodNames) {
-                        src = src.replaceAll(name, NokogiriNamespaceContext.NOKOGIRI_PREFIX+":"+name);
-                    }
+        if(!handler.isNil()) {
+            if (!isContainsPrefix(src)) {
+                Set<String> methodNames = handler.getMetaClass().getMethods().keySet();
+                for (String name : methodNames) {
+                    src = src.replaceAll(name, NokogiriNamespaceContext.NOKOGIRI_PREFIX+":"+name);
                 }
-                xpath.setXPathFunctionResolver(NokogiriXPathFunctionResolver.create(handler));
             }
-            XPathExpression xpathExpression = xpath.compile(src);
-            return node_set(thread_context, xpathExpression);
-        } catch (XPathExpressionException xpee) {
-            xpee = new XPathExpressionException(src);
-            RubyException e = XmlSyntaxError.createXPathSyntaxError(getRuntime(), xpee);
-            throw new RaiseException(e);
         }
+        return node_set(thread_context, src);
     }
 
-    protected IRubyObject node_set(ThreadContext thread_context, XPathExpression xpathExpression) {
-        XmlNodeSet result = null;
-        try {  
-            result = tryGetNodeSet(thread_context, xpathExpression);
-            return result;
+    protected IRubyObject node_set(ThreadContext thread_context, String expr) {
+        try {
+          return tryGetNodeSet(thread_context, expr);
         } catch (XPathExpressionException xpee) {
-            try {
-                return tryGetOpaqueValue(xpathExpression);
-            } catch (XPathExpressionException xpee_opaque) {
-                 RubyException e = XmlSyntaxError.createXPathSyntaxError(getRuntime(), xpee_opaque);
-                 throw new RaiseException(e);
-            }
+          RubyException e = XmlSyntaxError.createXPathSyntaxError(getRuntime(), xpee);
+          throw new RaiseException(e);
         }
     }
-    
-    private XmlNodeSet tryGetNodeSet(ThreadContext thread_context, XPathExpression xpathExpression) throws XPathExpressionException {
-        NodeList nodeList = (NodeList)xpathExpression.evaluate(context.node, XPathConstants.NODESET);
-        XmlNodeSet xmlNodeSet = (XmlNodeSet) NokogiriService.XML_NODESET_ALLOCATOR.allocate(getRuntime(), getNokogiriClass(getRuntime(), "Nokogiri::XML::NodeSet"));
-        xmlNodeSet.setNodeList(nodeList);
-        xmlNodeSet.initialize(thread_context.getRuntime(), context);
-        return xmlNodeSet;    
-    }
 
-    private static Pattern boolean_pattern = Pattern.compile("true|false");
-    
-    private IRubyObject tryGetOpaqueValue(XPathExpression xpathExpression) throws XPathExpressionException {
-        String string = (String)xpathExpression.evaluate(context.node, XPathConstants.STRING);
-        Double value = null;
-        if ((value = getDoubleValue(string)) != null) {
-            return new RubyFloat(getRuntime(), value);
-        }
-        if (doesMatch(boolean_pattern, string.toLowerCase())) return RubyBoolean.newBoolean(getRuntime(), Boolean.parseBoolean(string));
-        return RubyString.newString(getRuntime(), string);
-    }
-    
-    private Double getDoubleValue(String value) {
+    private IRubyObject tryGetNodeSet(ThreadContext thread_context, String expr) throws XPathExpressionException {
+        XObject xobj = null;
+
+        Node contextNode = context.node;
+
         try {
-            return Double.valueOf(value);
-        } catch (NumberFormatException e) {
-            return null;
+          com.sun.org.apache.xpath.internal.XPath xpathInternal = new com.sun.org.apache.xpath.internal.XPath (expr, null,
+                      prefixResolver, com.sun.org.apache.xpath.internal.XPath.SELECT );
+
+          // We always need to have a ContextNode with Xalan XPath implementation
+          // To allow simple expression evaluation like 1+1 we are setting
+          // dummy Document as Context Node
+
+          if ( contextNode == null )
+              xobj = xpathInternal.execute(xpathSupport, DTM.NULL, prefixResolver);
+          else
+              xobj = xpathInternal.execute(xpathSupport, contextNode, prefixResolver);
+
+          switch (xobj.getType()) {
+          case XObject.CLASS_BOOLEAN:
+            return thread_context.getRuntime().newBoolean(xobj.bool());
+          case XObject.CLASS_NUMBER:
+            return thread_context.getRuntime().newFloat(xobj.num());
+          case XObject.CLASS_NODESET:
+            NodeList nodeList = xobj.nodelist();
+            XmlNodeSet xmlNodeSet = (XmlNodeSet) NokogiriService.XML_NODESET_ALLOCATOR.allocate(getRuntime(), getNokogiriClass(getRuntime(), "Nokogiri::XML::NodeSet"));
+            xmlNodeSet.setNodeList(nodeList);
+            xmlNodeSet.initialize(thread_context.getRuntime(), context);
+            return xmlNodeSet;
+          default:
+            return thread_context.getRuntime().newString(xobj.str());
+          }
+        } catch(TransformerException ex) {
+          throw new XPathExpressionException(expr);
         }
     }
-    
-    private boolean doesMatch(Pattern pattern, String string) {
-        Matcher m = pattern.matcher(string);
-        return m.matches();
-    }
 
     private boolean isContainsPrefix(String str) {
-        Set<String> prefixes = ((NokogiriNamespaceContext)xpath.getNamespaceContext()).getAllPrefixes();
+        Set<String> prefixes = nsContext.getAllPrefixes();
         for (String prefix : prefixes) {
             if (str.contains(prefix + ":")) {
                 return true;
@@ -190,14 +233,13 @@ public class XmlXpathContext extends RubyObject {
 
     @JRubyMethod
     public IRubyObject register_ns(ThreadContext context, IRubyObject prefix, IRubyObject uri) {
-        ((NokogiriNamespaceContext) xpath.getNamespaceContext()).registerNamespace((String)prefix.toJava(String.class), (String)uri.toJava(String.class));
+        nsContext.registerNamespace((String)prefix.toJava(String.class), (String)uri.toJava(String.class));
         return this;
     }
 
     @JRubyMethod
     public IRubyObject register_variable(ThreadContext context, IRubyObject name, IRubyObject value) {
-        ((NokogiriXPathVariableResolver) xpath.getXPathVariableResolver()).
-            registerVariable((String)name.toJava(String.class), (String)value.toJava(String.class));
+        variableResolver.registerVariable((String)name.toJava(String.class), (String)value.toJava(String.class));
         return this;
     }
 }

data/ext/java/nokogiri/internals/IgnoreSchemaErrorsErrorHandler.java

@@ -0,0 +1,20 @@
+package nokogiri.internals;
+
+import org.xml.sax.ErrorHandler;
+import org.xml.sax.SAXException;
+import org.xml.sax.SAXParseException;
+
+public class IgnoreSchemaErrorsErrorHandler implements ErrorHandler {
+
+    @Override
+    public void warning(SAXParseException exception) throws SAXException {
+    }
+
+    @Override
+    public void error(SAXParseException exception) throws SAXException {
+    }
+
+    @Override
+    public void fatalError(SAXParseException exception) throws SAXException {
+    }
+}

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

@@ -76,8 +76,6 @@ public class NokogiriHandler extends DefaultHandler2 implements XmlDeclHandler {
     private final LinkedList<XmlSyntaxError> errors = new LinkedList<XmlSyntaxError>();
 
     private Locator locator;
-    private final ArrayDeque<Integer> lines;
-    private final ArrayDeque<Integer> columns;
     private static String htmlParserName = "Nokogiri::HTML::SAX::Parser";
     private boolean needEmptyAttrCheck = false;
 
@@ -85,8 +83,6 @@ public class NokogiriHandler extends DefaultHandler2 implements XmlDeclHandler {
         this.ruby = runtime;
         this.attrClass = (RubyClass) runtime.getClassFromPath("Nokogiri::XML::SAX::Parser::Attribute");
         this.object = object;
-        lines = new ArrayDeque<Integer>();
-        columns = new ArrayDeque<Integer>();
         String objectName = object.getMetaClass().getName();
         if (htmlParserName.equals(objectName)) needEmptyAttrCheck = true;
     }
@@ -141,10 +137,7 @@ public class NokogiriHandler extends DefaultHandler2 implements XmlDeclHandler {
 
         ThreadContext context = ruby.getCurrentContext();
         boolean fromFragmentHandler = false; // isFromFragmentHandler();
-        
-        lines.add(locator.getLineNumber());
-        columns.add(locator.getColumnNumber() - 1); // libxml counts from 0 while java does from 1
-        
+
         for (int i = 0; i < attrs.getLength(); i++) {
             String u = attrs.getURI(i);
             String qn = attrs.getQName(i);
@@ -208,11 +201,11 @@ public class NokogiriHandler extends DefaultHandler2 implements XmlDeclHandler {
     }
     
     public Integer getLine() {
-        return lines.pop();
+        return locator.getLineNumber();
     }
     
     public Integer getColumn() {
-        return columns.pop();
+        return locator.getColumnNumber() - 1;
     }
     
     private boolean isFromFragmentHandler() {

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

@@ -1,7 +1,7 @@
 /**
  * (The MIT License)
  *
- * Copyright (c) 2008 - 2012:
+ * Copyright (c) 2008 - 2014:
  *
  * * {Aaron Patterson}[http://tenderlovemaking.com]
  * * {Mike Dalessio}[http://mike.daless.io]
@@ -60,6 +60,7 @@ import nokogiri.XmlNamespace;
 import nokogiri.XmlNode;
 import nokogiri.XmlProcessingInstruction;
 import nokogiri.XmlText;
+import nokogiri.XmlXpathContext;
 
 import org.jcodings.specific.UTF8Encoding;
 import org.jruby.Ruby;
@@ -93,6 +94,20 @@ public class NokogiriHelpers {
         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)
@@ -175,7 +190,7 @@ public class NokogiriHelpers {
     }
     
     public static RubyClass getNokogiriClass(Ruby ruby, String name) {
-        return NokogiriService.nokogiriClassCache.get(name);
+        return NokogiriService.getNokogiriClassCache(ruby).get(name);
     }
 
     public static IRubyObject stringOrNil(Ruby runtime, String s) {
@@ -542,7 +557,7 @@ public class NokogiriHelpers {
     private static Pattern decoded_pattern = Pattern.compile("&|>|<|\r");
     private static String[] encoded = {"&amp;", "&gt;", "&lt;", "&#13;"};
     private static String[] decoded = {"&", ">", "<", "\r"};
-    
+
     private static String convert(Pattern ptn, String input, String[] oldChars, String[] newChars)  {
         Matcher matcher = ptn.matcher(input);
         boolean result = matcher.find();
@@ -562,11 +577,11 @@ public class NokogiriHelpers {
         matcher.appendTail(sb);
         return sb.toString();
     }
-    
+
     public static String encodeJavaString(String s) {
         return convert(decoded_pattern, s, decoded, encoded);
     }
-    
+
     public static String decodeJavaString(String s) {
         return convert(encoded_pattern, s, encoded, decoded);
     }
@@ -602,7 +617,7 @@ public class NokogiriHelpers {
     public static boolean isXmlBase(String attrName) {
         return "xml:base".equals(attrName) || "xlink:href".equals(attrName);
     }
-    
+
     public static boolean isWhitespaceText(ThreadContext context, IRubyObject obj) {
         if (obj == null || obj.isNil()) return false;
 
@@ -613,11 +628,11 @@ public class NokogiriHelpers {
         String content = rubyStringToString(node.content(context));
         return content.trim().length() == 0;
     }
-    
+
     public static boolean isWhitespaceText(String s) {
         return s.trim().length() == 0;
     }
-    
+
     public static String canonicalizeWhitespce(String s) {
         StringBuilder sb = new StringBuilder();
         char[] chars = s.toCharArray();
@@ -648,14 +663,14 @@ public class NokogiriHelpers {
         RubyArray array = RubyArray.newArray(ruby, nodes.getLength());
         return nodeListToRubyArray(ruby, nodes, array);
     }
-    
+
     public static RubyArray nodeListToRubyArray(Ruby ruby, NodeList nodes, RubyArray array) {
         for(int i = 0; i < nodes.getLength(); i++) {
             array.append(NokogiriHelpers.getCachedNodeOrCreate(ruby, nodes.item(i)));
         }
         return array;
     }
-    
+
     public static RubyArray nodeArrayToRubyArray(Ruby ruby, Node[] nodes) {
         RubyArray n = RubyArray.newArray(ruby, nodes.length);
         for(int i = 0; i < nodes.length; i++) {
@@ -663,7 +678,7 @@ public class NokogiriHelpers {
         }
         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++) {
@@ -671,7 +686,7 @@ public class NokogiriHelpers {
         }
         return n;
     }
-    
+
     public static String getValidEncoding(Ruby runtime, IRubyObject encoding) {
         if (encoding.isNil()) {
             return guessEncoding();
@@ -679,7 +694,7 @@ public class NokogiriHelpers {
             return ignoreInvalidEncoding(runtime, encoding);
         }
     }
-    
+
     private static String guessEncoding() {
         String name = null;
         if (name == null) name = System.getProperty("file.encoding");
@@ -694,7 +709,7 @@ public class NokogiriHelpers {
         if (charsetNames.contains(givenEncoding)) return givenEncoding;
         else return guessEncoding();
     }
-    
+
     public static String adjustSystemIdIfNecessary(String currentDir, String scriptFileName, String baseURI, String systemId) {
         if (systemId == null) return systemId;
         File file = new File(systemId);
@@ -705,7 +720,7 @@ public class NokogiriHelpers {
         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 = null;
@@ -719,13 +734,13 @@ public class NokogiriHelpers {
         if (dtdFile.exists()) return dtdFile.getPath();
         return null;
     }
-    
+
     public static boolean isUTF8(String encoding) {
         if (encoding == null) return true;   // no need to convert encoding
         int ret = Charset.forName(encoding).compareTo(Charset.forName("UTF-8"));
         return ret == 0;
     }
-    
+
     public static byte[] convertEncoding(Charset output_charset, String input_string) throws CharacterCodingException {
         CharsetEncoder encoder = output_charset.newEncoder();
         CharBuffer charBuffer = CharBuffer.wrap(input_string);
@@ -746,7 +761,6 @@ public class NokogiriHelpers {
         } else {
             return NokogiriHelpers.nkf(runtime, ruby_encoding, thing);
         }
-        
     }
 
     // This method is used from HTML documents. HTML meta tag with encoding specification
@@ -775,7 +789,7 @@ public class NokogiriHelpers {
         } catch (ClassNotFoundException e1) {
             try {
                 // Before JRuby 1.7
-                nkfClass = runtime.getClassLoader().loadClass("org.jruby.RubyNKF");  
+                nkfClass = runtime.getClassLoader().loadClass("org.jruby.RubyNKF");
             } catch (ClassNotFoundException e2) {
                 return thing;
             }
@@ -798,7 +812,7 @@ public class NokogiriHelpers {
             return thing;
         }
     }
-    
+
     private static Charset shift_jis = Charset.forName("Shift_JIS");
     private static Charset jis = Charset.forName("ISO-2022-JP");
     private static Charset euc_jp = Charset.forName("EUC-JP");
@@ -812,11 +826,14 @@ public class NokogiriHelpers {
       return !shouldEncode(text);
     }
 
+    public static NokogiriNamespaceCache getNamespaceCacheFormNode(Node n) {
+        XmlDocument xmlDoc = (XmlDocument)getCachedNode(n.getOwnerDocument());
+        return xmlDoc.getNamespaceCache();
+    }
+
     public static Node renameNode(Node n, String namespaceURI, String qualifiedName) throws DOMException {
         Document doc = n.getOwnerDocument();
-        XmlDocument xmlDoc = (XmlDocument)getCachedNode(doc);
-        NokogiriNamespaceCache nsCache = xmlDoc.getNamespaceCache();
-        int oldHash = n.hashCode();
+        NokogiriNamespaceCache nsCache = getNamespaceCacheFormNode(n);
         Node result = doc.renameNode(n, namespaceURI, qualifiedName);
         if (result != n) {
             nsCache.replaceNode(n, result);