nokogiri 1.7.2-java → 1.8.0-java

data/ext/java/nokogiri/XmlAttr.java

@@ -56,7 +56,7 @@ import org.w3c.dom.Node;
  */
 
 @JRubyClass(name="Nokogiri::XML::Attr", parent="Nokogiri::XML::Node")
-public class XmlAttr extends XmlNode{
+public class XmlAttr extends XmlNode {
 
     public static final String[] HTML_BOOLEAN_ATTRS = {
         "checked", "compact", "declare", "defer", "disabled", "ismap",
@@ -117,31 +117,6 @@ public class XmlAttr extends XmlNode{
         return false;
     }
 
-
-    private String serializeAttrTextContent(String s, boolean htmlDoc) {
-        if (s == null) return "";
-
-        char[] c = s.toCharArray();
-        StringBuffer buffer = new StringBuffer(c.length);
-
-        for(int i = 0; i < c.length; i++) {
-            switch(c[i]){
-            case '\n': buffer.append("&#10;"); break;
-            case '\r': buffer.append("&#13;"); break;
-            case '\t': buffer.append("&#9;"); break;
-            case '"': if (htmlDoc) buffer.append("%22"); 
-                else buffer.append("&quot;");
-                break;
-            case '<': buffer.append("&lt;"); break;
-            case '>': buffer.append("&gt;"); break;
-            case '&': buffer.append("&amp;"); break;
-            default: buffer.append(c[i]);
-            }
-        }
-
-        return buffer.toString();
-    }
-
     @Override
     @JRubyMethod(name = {"content", "value", "to_s"})
     public IRubyObject content(ThreadContext context) {

data/ext/java/nokogiri/XmlCdata.java

@@ -70,7 +70,6 @@ public class XmlCdata extends XmlText {
         IRubyObject doc = args[0];
         content = args[1];
         XmlDocument xmlDoc =(XmlDocument) ((XmlNode) doc).document(context);
-        doc = xmlDoc;
         Document document = xmlDoc.getDocument();
         Node node = document.createCDATASection((content.isNil()) ? null : rubyStringToString(content));
         setNode(context, node);

data/ext/java/nokogiri/XmlComment.java

@@ -69,7 +69,7 @@ public class XmlComment extends XmlNode {
         IRubyObject doc = args[0];
         IRubyObject text = args[1];
 
-        XmlDocument xmlDoc = null;
+        XmlDocument xmlDoc;
         if (doc instanceof XmlDocument) {
             xmlDoc = (XmlDocument) doc;
             

data/ext/java/nokogiri/XmlDocument.java

@@ -249,7 +249,7 @@ public class XmlDocument extends XmlNode {
      */
     @JRubyMethod(name="new", meta = true, rest = true, required=0)
     public static IRubyObject rbNew(ThreadContext context, IRubyObject klazz, IRubyObject[] args) {
-        XmlDocument xmlDocument = null;
+        XmlDocument xmlDocument;
         try {
             Document docNode = createNewDocument();
             if ("Nokogiri::HTML::Document".equals(((RubyClass)klazz).getName())) {
@@ -281,8 +281,7 @@ public class XmlDocument extends XmlNode {
     }
 
     @Override
-    @JRubyMethod
-    public IRubyObject document(ThreadContext context) {
+    IRubyObject document(Ruby runtime) {
         return this;
     }
 
@@ -575,7 +574,7 @@ public class XmlDocument extends XmlNode {
      */
     @JRubyMethod(optional=3)
     public IRubyObject canonicalize(ThreadContext context, IRubyObject[] args, Block block) {
-        Integer mode = 0;
+        int mode = 0;
         String inclusive_namespace = null;
         Boolean with_comments = false;
         if (args.length > 0 && !(args[0].isNil())) {
@@ -586,7 +585,7 @@ public class XmlDocument extends XmlNode {
                 throw context.getRuntime().newTypeError("Expected array");
             }
             if (!args[1].isNil()) {
-              inclusive_namespace = (String)((RubyArray)args[1])
+              inclusive_namespace = ((RubyArray)args[1])
                 .join(context, context.getRuntime().newString(" "))
                 .asString()
                 .asJavaString(); // OMG I wish I knew JRuby better, this is ugly

data/ext/java/nokogiri/XmlDocumentFragment.java

@@ -53,6 +53,7 @@ import org.jruby.anno.JRubyMethod;
 import org.jruby.javasupport.util.RuntimeHelpers;
 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.NamedNodeMap;
 
@@ -106,14 +107,12 @@ public class XmlDocumentFragment extends XmlNode {
         return fragment;
     }
 
-    private static boolean isTag(RubyString ruby_string) {
-        String str = rubyStringToString(ruby_string);
-        if (str.startsWith("<") && str.endsWith(">")) return true;
-        return false;
-    }
+    private static final ByteList TAG_BEG = ByteList.create("<");
+    private static final ByteList TAG_END = ByteList.create(">");
 
-    private static Pattern qname_pattern = Pattern.compile("[^</:>\\s]+:[^</:>=\\s]+");
-    private static Pattern starttag_pattern = Pattern.compile("<[^</>]+>");
+    private static boolean isTag(final RubyString str) {
+        return str.getByteList().startsWith(TAG_BEG) && str.getByteList().endsWith(TAG_END);
+    }
 
     private static boolean isNamespaceDefined(String qName, NamedNodeMap nodeMap) {
         if (isNamespace(qName.intern())) return true;
@@ -128,39 +127,48 @@ public class XmlDocumentFragment extends XmlNode {
         }
         return false;
     }
-    
+
+    private static final Pattern QNAME_RE = Pattern.compile("[^</:>\\s]+:[^</:>=\\s]+");
+    private static final Pattern START_TAG_RE = Pattern.compile("<[^</>]+>");
+
     private static String addNamespaceDeclIfNeeded(XmlDocument doc, String tags) {
         if (doc.getDocument() == null) return tags;
         if (doc.getDocument().getDocumentElement() == null) return tags;
-        Matcher matcher = starttag_pattern.matcher(tags);
-        Map<String, String> rewriteTable = new HashMap<String, String>();
-        while(matcher.find()) {
+        Matcher matcher = START_TAG_RE.matcher(tags);
+        Map<CharSequence, CharSequence> rewriteTable = null;
+        while (matcher.find()) {
             String start_tag = matcher.group();
-            Matcher matcher2 = qname_pattern.matcher(start_tag);
-            while(matcher2.find()) {
+            Matcher matcher2 = QNAME_RE.matcher(start_tag);
+            while (matcher2.find()) {
                 String qName = matcher2.group();
                 NamedNodeMap nodeMap = doc.getDocument().getDocumentElement().getAttributes();
                 if (isNamespaceDefined(qName, nodeMap)) {
-                    String namespaceDecl = getNamespceDecl(getPrefix(qName), nodeMap);
+                    CharSequence namespaceDecl = getNamespaceDecl(getPrefix(qName), nodeMap);
                     if (namespaceDecl != null) {
-                        rewriteTable.put("<"+qName+">", "<"+qName + " " + namespaceDecl+">");
+                        if (rewriteTable == null) rewriteTable = new HashMap(8, 1);
+                        StringBuilder str = new StringBuilder(qName.length() + namespaceDecl.length() + 3);
+                        String key = str.append('<').append(qName).append('>').toString();
+                        str.setCharAt(key.length() - 1, ' '); // (last) '>' -> ' '
+                        rewriteTable.put(key, str.append(namespaceDecl).append('>'));
                     }
                 }
             }
         }
-        Set<String> keys = rewriteTable.keySet();
-        for (String key : keys) {
-            tags = tags.replace(key, rewriteTable.get(key));
+        if (rewriteTable != null) {
+            for (Map.Entry<CharSequence, CharSequence> e : rewriteTable.entrySet()) {
+                tags = tags.replace(e.getKey(), e.getValue());
+            }
         }
         
         return tags;
     }
     
-    private static String getNamespceDecl(String prefix, NamedNodeMap nodeMap) {
+    private static CharSequence getNamespaceDecl(final String prefix, NamedNodeMap nodeMap) {
         for (int i=0; i < nodeMap.getLength(); i++) {
-            Attr attr = (Attr)nodeMap.item(i);
+            Attr attr = (Attr) nodeMap.item(i);
             if (prefix.equals(attr.getLocalName())) {
-                return attr.getName() + "=\"" + attr.getValue() + "\"";
+                return new StringBuilder().
+                    append(attr.getName()).append('=').append('"').append(attr.getValue()).append('"');
             }
         }
         return null;

data/ext/java/nokogiri/XmlDtd.java

@@ -130,7 +130,7 @@ public class XmlDtd extends XmlNode {
                                   IRubyObject external_id,
                                   IRubyObject system_id) {
 
-        DocumentType placeholder = null;
+        DocumentType placeholder;
         if (doc.getDoctype() == null) {
           String javaName = NokogiriHelpers.rubyStringToString(name);
           String javaExternalId = NokogiriHelpers.rubyStringToString(external_id);

data/ext/java/nokogiri/XmlElement.java

@@ -68,21 +68,20 @@ public class XmlElement extends XmlNode {
     
     @Override
     public void accept(ThreadContext context, SaveContextVisitor visitor) {
-        visitor.enter((Element)node);
+        visitor.enter((Element) node);
         XmlNodeSet xmlNodeSet = (XmlNodeSet) children(context);
         if (xmlNodeSet.length() > 0) {
-            RubyArray array = (RubyArray) xmlNodeSet.to_a(context);
-            for(int i = 0; i < array.getLength(); i++) {
-                Object item = array.get(i);
+            RubyArray nodes = xmlNodeSet.nodes;
+            for( int i = 0; i < nodes.size(); i++ ) {
+                Object item = nodes.eltInternal(i);
                 if (item instanceof XmlNode) {
-                  XmlNode cur = (XmlNode) item;
-                  cur.accept(context, visitor);
-                } else if (item instanceof XmlNamespace) {
-                    XmlNamespace cur = (XmlNamespace)item;
-                    cur.accept(context, visitor);
+                    ((XmlNode) item).accept(context, visitor);
+                }
+                else if (item instanceof XmlNamespace) {
+                    ((XmlNamespace) item).accept(context, visitor);
                 }
             }
         }
-        visitor.leave((Element)node);
+        visitor.leave((Element) node);
     }
 }

data/ext/java/nokogiri/XmlEntityDecl.java

@@ -37,7 +37,6 @@ import static nokogiri.internals.NokogiriHelpers.getNokogiriClass;
 import org.jruby.Ruby;
 import org.jruby.RubyClass;
 import org.jruby.RubyFixnum;
-import org.jruby.RubyNil;
 import org.jruby.anno.JRubyClass;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.runtime.ThreadContext;
@@ -117,7 +116,7 @@ public class XmlEntityDecl extends XmlNode {
     @JRubyMethod
     public IRubyObject node_name(ThreadContext context) {
         IRubyObject value = getAttribute(context, "name");
-        if (value instanceof RubyNil) value = name;
+        if (value.isNil()) value = name;
         return value;
     }
 
@@ -131,7 +130,7 @@ public class XmlEntityDecl extends XmlNode {
     @JRubyMethod
     public IRubyObject content(ThreadContext context) {
         IRubyObject value = getAttribute(context, "value");
-        if (value instanceof RubyNil) value = content;
+        if (value.isNil()) value = content;
         return value;
     }
 
@@ -144,14 +143,14 @@ public class XmlEntityDecl extends XmlNode {
     @JRubyMethod
     public IRubyObject system_id(ThreadContext context) {
         IRubyObject value = getAttribute(context, "sysid");
-        if (value instanceof RubyNil) value = system_id;
+        if (value.isNil()) value = system_id;
         return value;
     }
 
     @JRubyMethod
     public IRubyObject external_id(ThreadContext context) {
         IRubyObject value = getAttribute(context, "pubid");
-        if (value instanceof RubyNil) value = external_id;
+        if (value.isNil()) value = external_id;
         return value;
     }
 

data/ext/java/nokogiri/XmlNode.java

@@ -36,6 +36,8 @@ import static java.lang.Math.max;
 import static nokogiri.internals.NokogiriHelpers.getCachedNodeOrCreate;
 import static nokogiri.internals.NokogiriHelpers.clearCachedNode;
 import static nokogiri.internals.NokogiriHelpers.clearXpathContext;
+import static nokogiri.internals.NokogiriHelpers.convertEncoding;
+import static nokogiri.internals.NokogiriHelpers.convertString;
 import static nokogiri.internals.NokogiriHelpers.getNokogiriClass;
 import static nokogiri.internals.NokogiriHelpers.nodeArrayToRubyArray;
 import static nokogiri.internals.NokogiriHelpers.nonEmptyStringOrNil;
@@ -44,6 +46,7 @@ import static nokogiri.internals.NokogiriHelpers.stringOrNil;
 
 import java.io.ByteArrayInputStream;
 import java.io.InputStream;
+import java.nio.ByteBuffer;
 import java.nio.charset.CharacterCodingException;
 import java.nio.charset.Charset;
 import java.util.ArrayList;
@@ -60,6 +63,7 @@ import org.apache.xerces.dom.CoreDocumentImpl;
 import org.jruby.Ruby;
 import org.jruby.RubyArray;
 import org.jruby.RubyClass;
+import org.jruby.RubyInteger;
 import org.jruby.RubyFixnum;
 import org.jruby.RubyModule;
 import org.jruby.RubyObject;
@@ -72,6 +76,7 @@ import org.jruby.runtime.Block;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.Visibility;
 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.DocumentFragment;
@@ -119,12 +124,11 @@ public class XmlNode extends RubyObject {
      * in <code>context</code>.
      */
     protected static XmlNode asXmlNode(ThreadContext context, IRubyObject node) {
-        if (node == null || !(node instanceof XmlNode)) {
-            Ruby ruby = context.getRuntime();
-            throw ruby.newTypeError(node, getNokogiriClass(ruby, "Nokogiri::XML::Node"));
-        } else {
-            return (XmlNode) node;
+        if ( !(node instanceof XmlNode) ) {
+            final Ruby runtime = context.getRuntime();
+            throw runtime.newTypeError(node == null ? runtime.getNil() : node, getNokogiriClass(runtime, "Nokogiri::XML::Node"));
         }
+        return (XmlNode) node;
     }
 
     /**
@@ -132,11 +136,8 @@ public class XmlNode extends RubyObject {
      * raise a type error in <code>context</code>.
      */
     protected static XmlNode asXmlNodeOrNull(ThreadContext context, IRubyObject node) {
-        if (node == null || node.isNil()) {
-            return null;
-        } else {
-            return asXmlNode(context, node);
-        }
+        if (node == null || node.isNil()) return null;
+        return asXmlNode(context, node);
     }
 
     /**
@@ -219,15 +220,15 @@ public class XmlNode extends RubyObject {
         setNode(ruby.getCurrentContext(), node);
     }
 
-    protected void decorate(Ruby ruby) {
+    protected void decorate(final ThreadContext context) {
         if (node != null) {
             resetCache();
 
             if (node.getNodeType() != Node.DOCUMENT_NODE) {
-                doc = document(ruby.getCurrentContext());
+                doc = document(context.runtime);
 
-                if (doc != null && doc.isTrue()) {
-                    RuntimeHelpers.invoke(ruby.getCurrentContext(), doc, "decorate", this);
+                if (doc != null && ! doc.isNil()) {
+                    RuntimeHelpers.invoke(context, doc, "decorate", this);
                 }
             }
         }
@@ -290,14 +291,14 @@ public class XmlNode extends RubyObject {
         Ruby ruby = context.getRuntime();
         RubyClass klazz = (RubyClass) cls;
 
-        if (cls.equals(getNokogiriClass(ruby, "Nokogiri::XML::Node"))) {
+        if ("Nokogiri::XML::Node".equals(klazz.getName())) {
             klazz = getNokogiriClass(ruby, "Nokogiri::XML::Element");
         }
 
         XmlNode xmlNode = (XmlNode) klazz.allocate();
         xmlNode.init(context, args);
         xmlNode.callInit(args, block);
-        if (xmlNode.node == null) context.getRuntime().newRuntimeError("NODE IS NULL");
+        assert xmlNode.node != null;
         if (block.isGiven()) block.call(context, xmlNode);
         return xmlNode;
     }
@@ -330,7 +331,7 @@ public class XmlNode extends RubyObject {
             throw getRuntime().newArgumentError("node must have owner document");
         }
 
-        Element element = null;
+        Element element;
         String node_name = rubyStringToString(name);
         String prefix = NokogiriHelpers.getPrefix(node_name);
         String namespace_uri = null;
@@ -380,7 +381,7 @@ public class XmlNode extends RubyObject {
         boolean closingTag = false;
         String indentString = rubyStringToString(indentStringObject);
         int lengthInd = indentString.length();
-        StringBuffer curInd = new StringBuffer();
+        StringBuilder curInd = new StringBuilder();
 
         resultLines[0] = lines[0];
 
@@ -404,10 +405,9 @@ public class XmlNode extends RubyObject {
             closingTag = false;
         }
 
-        StringBuffer result = new StringBuffer();
+        StringBuilder result = new StringBuilder();
         for(int i = 0; i < resultLines.length; i++) {
-            result.append(resultLines[i]);
-            result.append("\n");
+            result.append(resultLines[i]).append('\n');
         }
 
         return result.toString();
@@ -479,7 +479,7 @@ public class XmlNode extends RubyObject {
         String nsURI = e.lookupNamespaceURI(prefix);
         this.node = NokogiriHelpers.renameNode(e, nsURI, e.getNodeName());
 
-        if (nsURI == null || nsURI == "") {
+        if (nsURI == null || nsURI.isEmpty()) {
             return;
         }
 
@@ -488,12 +488,12 @@ public class XmlNode extends RubyObject {
 
             for (int i = 0; i < attrs.getLength(); i++) {
                 Attr attr = (Attr) attrs.item(i);
-                String nsUri = "";
                 String attrPrefix = attr.getPrefix();
                 if (attrPrefix == null) {
                     attrPrefix = NokogiriHelpers.getPrefix(attr.getNodeName());
                 }
                 String nodeName = attr.getNodeName();
+                String nsUri;
                 if ("xml".equals(attrPrefix)) {
                     nsUri = "http://www.w3.org/XML/1998/namespace";
                 } else if ("xmlns".equals(attrPrefix) || nodeName.equals("xmlns")) {
@@ -549,16 +549,22 @@ public class XmlNode extends RubyObject {
 
     public void setDocument(ThreadContext context, IRubyObject doc) {
         this.doc = doc;
-        setInstanceVariable("@document", doc);
+
+        setDocumentAndDecorate(context, this, doc);
+    }
+
+    // shared logic with XmlNodeSet
+    static void setDocumentAndDecorate(ThreadContext context, RubyObject self, IRubyObject doc) {
+        self.setInstanceVariable("@document", doc);
         if (doc != null) {
-            RuntimeHelpers.invoke(context, doc, "decorate", this);
+            RuntimeHelpers.invoke(context, doc, "decorate", self);
         }
     }
 
     public void setNode(ThreadContext context, Node node) {
         this.node = node;
 
-        decorate(context.getRuntime());
+        decorate(context);
 
         if (this instanceof XmlAttr) {
             ((XmlAttr)this).setNamespaceIfNecessary(context.getRuntime());
@@ -583,17 +589,15 @@ public class XmlNode extends RubyObject {
 
     protected IRubyObject getNodeName(ThreadContext context) {
         if (name != null) return name;
-        String str = null;
 
-        if (this.name == null && node != null) {
+        String str = null;
+        if (node != null) {
             str = node.getNodeName();
             str = NokogiriHelpers.getLocalPart(str);
         }
         if (str == null) str = "";
         if (str.startsWith("#")) str = str.substring(1);  // eliminates '#'
-        name = NokogiriHelpers.stringOrBlank(context.getRuntime(), str);
-
-        return name;
+        return name = NokogiriHelpers.stringOrBlank(context.getRuntime(), str);
     }
 
     /**
@@ -696,10 +700,9 @@ public class XmlNode extends RubyObject {
         // a node is blank if if it is a Text or CDATA node consisting of whitespace only
         if (node.getNodeType() == Node.TEXT_NODE || node.getNodeType() == Node.CDATA_SECTION_NODE) {
             String data = node.getTextContent();
-            if (data == null) return context.getRuntime().getTrue();
-            if ("".equals(data.trim())) return context.getRuntime().getTrue();
+            return context.runtime.newBoolean(data == null || data.isEmpty() || data.trim().isEmpty());
         }
-        return context.getRuntime().getFalse();
+        return context.runtime.getFalse();
     }
 
     @JRubyMethod
@@ -709,8 +712,16 @@ public class XmlNode extends RubyObject {
 
     @JRubyMethod
     public IRubyObject children(ThreadContext context) {
-        XmlNodeSet xmlNodeSet = (XmlNodeSet) NokogiriService.XML_NODESET_ALLOCATOR.allocate(context.getRuntime(), getNokogiriClass(context.getRuntime(), "Nokogiri::XML::NodeSet"));
-        xmlNodeSet.setNodeList(node.getChildNodes());
+        XmlNodeSet xmlNodeSet = XmlNodeSet.create(context.runtime);
+
+        NodeList nodeList = node.getChildNodes();
+        if (nodeList.getLength() > 0) {
+            xmlNodeSet.setNodeList(nodeList); // initializes @document from first node
+        }
+        else { // TODO this is very ripe for refactoring
+            setDocumentAndDecorate(context, xmlNodeSet, doc);
+        }
+
         return xmlNodeSet;
     }
 
@@ -815,13 +826,11 @@ public class XmlNode extends RubyObject {
             ctx = new HtmlDomParserContext(runtime, options);
             ((HtmlDomParserContext)ctx).enableDocumentFragment();
             istream = new ByteArrayInputStream((rubyStringToString(str)).getBytes());
-        } else if (document instanceof XmlDocument) {
+        } else {
             klass = getNokogiriClass(runtime, "Nokogiri::XML::Document");
             ctx = new XmlDomParserContext(runtime, options);
             String input = rubyStringToString(str);
             istream = new ByteArrayInputStream(input.getBytes());
-        } else {
-            return runtime.getNil();
         }
 
         ctx.setInputSource(istream);
@@ -869,84 +878,86 @@ public class XmlNode extends RubyObject {
     }
 
     private boolean isErrorIncreased(RubyArray baseErrors, RubyArray createdErrors) {
-        RubyFixnum length = ((RubyArray)createdErrors.op_diff(baseErrors)).length();
-        int diff_in_length = (Integer)length.toJava(Integer.class);
-        return diff_in_length > 0;
+        int length = ((RubyArray) createdErrors.op_diff(baseErrors)).size();
+        return length > 0;
     }
 
     @JRubyMethod(name = {"content", "text", "inner_text"})
     public IRubyObject content(ThreadContext context) {
+        return stringOrNil(context.getRuntime(), getContentImpl());
+    }
+
+    public CharSequence getContentImpl() {
         if (!node.hasChildNodes() && node.getNodeValue() == null &&
-            (node.getNodeType() == Node.TEXT_NODE || node.getNodeType() == Node.CDATA_SECTION_NODE))
-          return context.nil;
-        String textContent;
+            (node.getNodeType() == Node.TEXT_NODE || node.getNodeType() == Node.CDATA_SECTION_NODE)) {
+            return null;
+        }
+        CharSequence textContent;
         if (this instanceof XmlDocument) {
             Node node = ((Document)this.node).getDocumentElement();
             if (node == null) {
                 textContent = "";
             } else {
-                Node documentElement = ((Document)this.node).getDocumentElement();
-                StringBuffer buffer = new StringBuffer();
-                getTextContentRecursively(context, buffer, documentElement);
-                textContent = buffer.toString();
+                Node documentElement = ((Document) this.node).getDocumentElement();
+                textContent = getTextContentRecursively(new StringBuilder(), documentElement);
             }
         } else {
-            StringBuffer buffer = new StringBuffer();
-            getTextContentRecursively(context, buffer, node);
-            textContent = buffer.toString();
-        }
-        NokogiriHelpers.convertEncodingByNKFIfNecessary(context.getRuntime(), (XmlDocument)document(context), textContent);
-        return stringOrNil(context.getRuntime(), textContent);
-    }
-
-    private void getTextContentRecursively(ThreadContext context, StringBuffer buffer, Node currentNode) {
-      String textContent = currentNode.getNodeValue();
-      if (textContent != null && NokogiriHelpers.shouldDecode(currentNode))
-        textContent = NokogiriHelpers.decodeJavaString(textContent);
-      if (textContent != null)
-        buffer.append(textContent);
-      NodeList children = currentNode.getChildNodes();
-      for (int i = 0; i < children.getLength(); i++) {
-        Node child = children.item(i);
-        if (hasTextContent(child))
-          getTextContentRecursively(context, buffer, child);
-      }
+            textContent = getTextContentRecursively(new StringBuilder(), node);
+        }
+        // textContent = NokogiriHelpers.convertEncodingByNKFIfNecessary(context, (XmlDocument) document(context), textContent);
+        return textContent;
+    }
+
+    private StringBuilder getTextContentRecursively(StringBuilder buffer, Node currentNode) {
+        CharSequence textContent = currentNode.getNodeValue();
+        if (textContent != null && NokogiriHelpers.shouldDecode(currentNode)) {
+            textContent = NokogiriHelpers.decodeJavaString(textContent);
+        }
+        if (textContent != null) buffer.append(textContent);
+        NodeList children = currentNode.getChildNodes();
+        for (int i = 0; i < children.getLength(); i++) {
+            Node child = children.item(i);
+            if (hasTextContent(child)) getTextContentRecursively(buffer, child);
+        }
+        return buffer;
     }
 
     private boolean hasTextContent(Node child) {
-      return child.getNodeType() != Node.COMMENT_NODE &&
-          child.getNodeType() != Node.PROCESSING_INSTRUCTION_NODE;
+        return child.getNodeType() != Node.COMMENT_NODE && child.getNodeType() != Node.PROCESSING_INSTRUCTION_NODE;
     }
 
     @JRubyMethod
-    public IRubyObject document(ThreadContext context) {
+    public final IRubyObject document(ThreadContext context) {
+        return document(context.runtime);
+    }
+
+    IRubyObject document(final Ruby runtime) {
         if (doc == null) {
             doc = (XmlDocument) node.getOwnerDocument().getUserData(NokogiriHelpers.CACHED_NODE);
         }
         if (doc == null) {
-            doc = getCachedNodeOrCreate(context.getRuntime(), node.getOwnerDocument());
+            doc = getCachedNodeOrCreate(runtime, node.getOwnerDocument());
             node.getOwnerDocument().setUserData(NokogiriHelpers.CACHED_NODE, doc, null);
         }
         return doc;
     }
 
     public IRubyObject dup() {
-        return this.dup_implementation(getMetaClass().getClassRuntime(), true);
+        return dup_implementation(getMetaClass().getClassRuntime(), true);
     }
 
     @JRubyMethod
     public IRubyObject dup(ThreadContext context) {
-        return this.dup_implementation(context, true);
+        return dup_implementation(context, true);
     }
 
     @JRubyMethod
     public IRubyObject dup(ThreadContext context, IRubyObject depth) {
-        boolean deep = (Integer)depth.toJava(Integer.class) != 0;
-
-        return this.dup_implementation(context, deep);
+        boolean deep = depth instanceof RubyInteger && RubyFixnum.fix2int(depth) != 0;
+        return dup_implementation(context, deep);
     }
 
-    protected IRubyObject dup_implementation(ThreadContext context, boolean deep) {
+    protected final IRubyObject dup_implementation(ThreadContext context, boolean deep) {
        return dup_implementation(context.getRuntime(), deep);
     }
 
@@ -957,17 +968,14 @@ public class XmlNode extends RubyObject {
         } catch (CloneNotSupportedException e) {
             throw runtime.newRuntimeError(e.toString());
         }
-        if (node == null) throw runtime.newRuntimeError("FFFFFFFFFUUUUUUU");
         Node newNode = node.cloneNode(deep);
         clone.node = newNode;
         return clone;
     }
 
-    public static IRubyObject encode_special_chars(ThreadContext context,
-                                                   IRubyObject string) {
-        String s = rubyStringToString(string);
-        String enc = NokogiriHelpers.encodeJavaString(s);
-        return context.getRuntime().newString(enc);
+    public static RubyString encode_special_chars(ThreadContext context, IRubyObject string) {
+        CharSequence str = NokogiriHelpers.encodeJavaString( rubyStringToString(string) );
+        return RubyString.newString(context.getRuntime(), str);
     }
 
     /**
@@ -1206,7 +1214,7 @@ public class XmlNode extends RubyObject {
     protected void setContent(IRubyObject content) {
         String javaContent = rubyStringToString(content);
         node.setTextContent(javaContent);
-        if (javaContent.length() == 0) return;
+        if (javaContent == null || javaContent.length() == 0) return;
         if (node.getNodeType() == Node.TEXT_NODE || node.getNodeType() == Node.CDATA_SECTION_NODE) return;
         if (node.getFirstChild() != null) {
             node.getFirstChild().setUserData(NokogiriHelpers.ENCODED_STRING, true, null);
@@ -1260,19 +1268,16 @@ public class XmlNode extends RubyObject {
         String encString = encoding.isNil() ? null : rubyStringToString(encoding);
 
         SaveContextVisitor visitor = 
-            new SaveContextVisitor((Integer) options.toJava(Integer.class), rubyStringToString(indentString), encString, isHtmlDoc(context), isFragment(), 0);
+            new SaveContextVisitor(RubyFixnum.fix2int(options), rubyStringToString(indentString), encString, isHtmlDoc(context), isFragment(), 0);
         accept(context, visitor);
 
-        IRubyObject rubyString = null;
+        final IRubyObject rubyString;
         if (NokogiriHelpers.isUTF8(encString)) {
-            rubyString = stringOrNil(context.getRuntime(), visitor.toString());
+            rubyString = convertString(context.getRuntime(), visitor.getInternalBuffer());
         } else {
-            try {
-                byte[] bytes = NokogiriHelpers.convertEncoding(Charset.forName(encString), visitor.toString());
-                rubyString = stringOrNil(context.getRuntime(), bytes);
-            } catch (CharacterCodingException e) {
-                throw context.getRuntime().newRuntimeError(e.getMessage());
-            }
+            ByteBuffer bytes = convertEncoding(Charset.forName(encString), visitor.getInternalBuffer());
+            ByteList str = new ByteList(bytes.array(), bytes.arrayOffset(), bytes.remaining());
+            rubyString = RubyString.newString(context.getRuntime(), str);
         }
         RuntimeHelpers.invoke(context, io, "write", rubyString);
 
@@ -1432,9 +1437,10 @@ public class XmlNode extends RubyObject {
 
     @JRubyMethod(name = {"unlink", "remove"})
     public IRubyObject unlink(ThreadContext context) {
-        if (node.getParentNode() != null) {
-            clearXpathContext(node.getParentNode());
-            node.getParentNode().removeChild(node);
+        final Node parent = node.getParentNode();
+        if (parent != null) {
+            parent.removeChild(node);
+            clearXpathContext(parent);
         }
         return this;
     }
@@ -1532,7 +1538,7 @@ public class XmlNode extends RubyObject {
     }
 
     protected enum AdoptScheme {
-        CHILD, PREV_SIBLING, NEXT_SIBLING, REPLACEMENT;
+        CHILD, PREV_SIBLING, NEXT_SIBLING, REPLACEMENT
     }
 
     /**
@@ -1682,10 +1688,6 @@ public class XmlNode extends RubyObject {
 
         Node nextSib = thisNode.getNextSibling();
 
-        if (nextSib != null &&
-            nextSib.getNodeType() == Node.TEXT_NODE &&
-            otherNode.getNodeType() == Node.TEXT_NODE) return;
-
         if (nextSib != null) {
             parent.insertBefore(otherNode, nextSib);
         } else {