nokogiri 1.10.10-java → 1.11.0-java

data/ext/java/nokogiri/HtmlSaxParserContext.java

@@ -32,28 +32,29 @@
 
 package nokogiri;
 
-import static nokogiri.internals.NokogiriHelpers.rubyStringToString;
-
 import java.io.ByteArrayInputStream;
 import java.io.InputStream;
 import java.nio.charset.Charset;
 import java.nio.charset.IllegalCharsetNameException;
 import java.nio.charset.UnsupportedCharsetException;
-import java.util.EnumSet;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-import nokogiri.internals.NokogiriHandler;
-
 import org.apache.xerces.parsers.AbstractSAXParser;
 import org.cyberneko.html.parsers.SAXParser;
-import org.jruby.*;
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyString;
 import org.jruby.anno.JRubyClass;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.xml.sax.SAXException;
 
+import nokogiri.internals.NokogiriHandler;
+import static nokogiri.internals.NokogiriHelpers.rubyStringToString;
+
 /**
  * Class for Nokogiri::HTML::SAX::ParserContext.
  *
@@ -65,10 +66,16 @@ import org.xml.sax.SAXException;
 @JRubyClass(name="Nokogiri::HTML::SAX::ParserContext", parent="Nokogiri::XML::SAX::ParserContext")
 public class HtmlSaxParserContext extends XmlSaxParserContext {
 
+    static HtmlSaxParserContext newInstance(final Ruby runtime, final RubyClass klazz) {
+        HtmlSaxParserContext instance = new HtmlSaxParserContext(runtime, klazz);
+        instance.initialize(runtime);
+        return instance;
+    }
+
     public HtmlSaxParserContext(Ruby ruby, RubyClass rubyClass) {
         super(ruby, rubyClass);
     }
-    
+
     @Override
     protected AbstractSAXParser createParser() throws SAXException {
         SAXParser parser = new SAXParser();
@@ -78,6 +85,11 @@ public class HtmlSaxParserContext extends XmlSaxParserContext {
                 "http://cyberneko.org/html/properties/names/elems", "lower");
             parser.setProperty(
                 "http://cyberneko.org/html/properties/names/attrs", "lower");
+
+            // NekoHTML should not try to guess the encoding based on the meta
+            // tags or other information in the document.  This is already
+            // handled by the EncodingReader.
+            parser.setFeature("http://cyberneko.org/html/features/scanner/ignore-specified-charset", true);
             return parser;
         } catch(SAXException ex) {
             throw new SAXException(
@@ -90,18 +102,17 @@ public class HtmlSaxParserContext extends XmlSaxParserContext {
                                            IRubyObject klazz,
                                            IRubyObject data,
                                            IRubyObject encoding) {
-        HtmlSaxParserContext ctx = (HtmlSaxParserContext) NokogiriService.HTML_SAXPARSER_CONTEXT_ALLOCATOR.allocate(context.getRuntime(), (RubyClass)klazz);
-        ctx.initialize(context.getRuntime());
-        String javaEncoding = findEncoding(context, encoding);
+        HtmlSaxParserContext ctx = HtmlSaxParserContext.newInstance(context.runtime, (RubyClass) klazz);
+        String javaEncoding = findEncodingName(context, encoding);
         if (javaEncoding != null) {
-            String input = applyEncoding(rubyStringToString(data), javaEncoding);
-            ByteArrayInputStream istream = new ByteArrayInputStream(input.getBytes());
+            CharSequence input = applyEncoding(rubyStringToString(data.convertToString()), javaEncoding);
+            ByteArrayInputStream istream = new ByteArrayInputStream(input.toString().getBytes());
             ctx.setInputSource(istream);
             ctx.getInputSource().setEncoding(javaEncoding);
         }
         return ctx;
     }
-    
+
     public enum EncodingType {
         NONE(0, "NONE"),
         UTF_8(1, "UTF-8"),
@@ -142,23 +153,38 @@ public class HtmlSaxParserContext extends XmlSaxParserContext {
         public String toString() {
             return name;
         }
-    }
-    
-    private static String findName(final int value) {
-        for (EncodingType type : EncodingType.values()) {
-            if (type.getValue() == value) return type.toString();
+
+        private static transient EncodingType[] values;
+
+        // NOTE: assuming ordinal == value
+        static EncodingType get(final int ordinal) {
+            EncodingType[] values = EncodingType.values;
+            if (values == null) {
+                values = EncodingType.values();
+                EncodingType.values = values;
+            }
+            if (ordinal >= 0 && ordinal < values.length) {
+                return values[ordinal];
+            }
+            return null;
         }
-        return null;
+
     }
-    
-    private static String findEncoding(ThreadContext context, IRubyObject encoding) {
+
+    private static String findEncodingName(final int value) {
+        EncodingType type = EncodingType.get(value);
+        if (type == null) return null;
+        assert type.value == value;
+        return type.name;
+    }
+
+    private static String findEncodingName(ThreadContext context, IRubyObject encoding) {
         String rubyEncoding = null;
         if (encoding instanceof RubyString) {
-            rubyEncoding = rubyStringToString(encoding);
+            rubyEncoding = rubyStringToString((RubyString) encoding);
         }
         else if (encoding instanceof RubyFixnum) {
-            int value = RubyFixnum.fix2int((RubyFixnum) encoding);
-            rubyEncoding = findName(value);
+            rubyEncoding = findEncodingName(RubyFixnum.fix2int((RubyFixnum) encoding));
         }
         if (rubyEncoding == null) return null;
         try {
@@ -168,39 +194,56 @@ public class HtmlSaxParserContext extends XmlSaxParserContext {
             throw context.getRuntime().newEncodingCompatibilityError(rubyEncoding + "is not supported");
         }
         catch (IllegalCharsetNameException e) {
-            throw context.getRuntime().newInvalidEncoding(e.getMessage());
+            throw context.getRuntime().newEncodingError(e.getMessage());
         }
     }
 
-    private static final Pattern CHARSET_PATTERN = Pattern.compile("charset(()|\\s)=(()|\\s)([a-z]|-|_|\\d)+");
+    private static final Pattern CHARSET_PATTERN = Pattern.compile("charset(()|\\s)=(()|\\s)([a-z]|-|_|\\d)+", Pattern.CASE_INSENSITIVE);
 
-    private static String applyEncoding(String input, String enc) {
-        String str = input.toLowerCase();
-        int start_pos = 0;
-        int end_pos = 0;
-        if (input.contains("meta") && input.contains("charset")) {
-            Matcher m = CHARSET_PATTERN.matcher(str);
+    private static CharSequence applyEncoding(final String input, final String enc) {
+        int start_pos = 0; int end_pos = 0;
+        if (containsIgnoreCase(input, "charset")) {
+            Matcher m = CHARSET_PATTERN.matcher(input);
             while (m.find()) {
                 start_pos = m.start();
                 end_pos = m.end();
             }
         }
         if (start_pos != end_pos) {
-            String substr = input.substring(start_pos, end_pos);
-            input = input.replace(substr, "charset=" + enc);
+            return new StringBuilder(input).replace(start_pos, end_pos, "charset=" + enc);
         }
         return input;
     }
 
+    private static boolean containsIgnoreCase(final String str, final String sub) {
+        final int len = sub.length();
+        final int max = str.length() - len;
+
+        if (len == 0) return true;
+        final char c0Lower = Character.toLowerCase(sub.charAt(0));
+        final char c0Upper = Character.toUpperCase(sub.charAt(0));
+
+        for (int i = 0; i <= max; i++) {
+            final char ch = str.charAt(i);
+            if (ch != c0Lower && Character.toLowerCase(ch) != c0Lower && Character.toUpperCase(ch) != c0Upper) {
+                continue; // first char doesn't match
+            }
+
+            if (str.regionMatches(true, i + 1, sub, 0 + 1, len - 1)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     @JRubyMethod(name="file", meta=true)
     public static IRubyObject parse_file(ThreadContext context,
-                                         IRubyObject klazz,
+                                         IRubyObject klass,
                                          IRubyObject data,
                                          IRubyObject encoding) {
-        HtmlSaxParserContext ctx = (HtmlSaxParserContext) NokogiriService.HTML_SAXPARSER_CONTEXT_ALLOCATOR.allocate(context.getRuntime(), (RubyClass)klazz);
-        ctx.initialize(context.getRuntime());
+        HtmlSaxParserContext ctx = HtmlSaxParserContext.newInstance(context.runtime, (RubyClass) klass);
         ctx.setInputSourceFile(context, data);
-        String javaEncoding = findEncoding(context, encoding);
+        String javaEncoding = findEncodingName(context, encoding);
         if (javaEncoding != null) {
             ctx.getInputSource().setEncoding(javaEncoding);
         }
@@ -209,13 +252,12 @@ public class HtmlSaxParserContext extends XmlSaxParserContext {
 
     @JRubyMethod(name="io", meta=true)
     public static IRubyObject parse_io(ThreadContext context,
-                                       IRubyObject klazz,
+                                       IRubyObject klass,
                                        IRubyObject data,
                                        IRubyObject encoding) {
-        HtmlSaxParserContext ctx = (HtmlSaxParserContext) NokogiriService.HTML_SAXPARSER_CONTEXT_ALLOCATOR.allocate(context.getRuntime(), (RubyClass)klazz);
-        ctx.initialize(context.getRuntime());
-        ctx.setInputSource(context, data, context.getRuntime().getNil());
-        String javaEncoding = findEncoding(context, encoding);
+        HtmlSaxParserContext ctx = HtmlSaxParserContext.newInstance(context.runtime, (RubyClass) klass);
+        ctx.setIOInputSource(context, data, context.nil);
+        String javaEncoding = findEncodingName(context, encoding);
         if (javaEncoding != null) {
             ctx.getInputSource().setEncoding(javaEncoding);
         }
@@ -226,27 +268,15 @@ public class HtmlSaxParserContext extends XmlSaxParserContext {
      * Create a new parser context that will read from a raw input stream.
      * Meant to be run in a separate thread by HtmlSaxPushParser.
      */
-    static HtmlSaxParserContext parse_stream(final Ruby runtime, RubyClass klazz, InputStream stream) {
-        HtmlSaxParserContext ctx = (HtmlSaxParserContext) NokogiriService.HTML_SAXPARSER_CONTEXT_ALLOCATOR.allocate(runtime, klazz);
-        ctx.initialize(runtime);
+    static HtmlSaxParserContext parse_stream(final Ruby runtime, RubyClass klass, InputStream stream) {
+        HtmlSaxParserContext ctx = HtmlSaxParserContext.newInstance(runtime, klass);
         ctx.setInputSource(stream);
         return ctx;
     }
 
     @Override
     protected void preParse(final Ruby runtime, IRubyObject handlerRuby, NokogiriHandler handler) {
-        // final String path = "Nokogiri::XML::FragmentHandler";
-        // final String docFrag =
-        //     "http://cyberneko.org/html/features/balance-tags/document-fragment";
-        // RubyObjectAdapter adapter = JavaEmbedUtils.newObjectAdapter();
-        // IRubyObject doc = adapter.getInstanceVariable(handlerRuby, "@document");
-        // RubyModule mod = runtime.getClassFromPath(path);
-        // try {
-        //     if (doc != null && !doc.isNil() && adapter.isKindOf(doc, mod))
-        //         parser.setFeature(docFrag, true);
-        // } catch (Exception e) {
-        //     // ignore
-        // }
+        // this function is meant to be empty.  It overrides the one in XmlSaxParserContext
     }
 
 }

data/ext/java/nokogiri/HtmlSaxPushParser.java

@@ -129,7 +129,7 @@ public class HtmlSaxPushParser extends RubyObject {
         final ByteArrayInputStream data = NokogiriHelpers.stringBytesToStream(chunk);
         if (data == null) {
             terminateTask(context.runtime);
-            throw new RaiseException(XmlSyntaxError.createHTMLSyntaxError(context.runtime)); // Nokogiri::HTML::SyntaxError
+            throw XmlSyntaxError.createHTMLSyntaxError(context.runtime).toThrowable(); // Nokogiri::HTML::SyntaxError
         }
 
         int errorCount0 = parserTask.getErrorCount();

data/ext/java/nokogiri/NokogiriService.java

@@ -258,7 +258,7 @@ public class NokogiriService implements BasicLibraryService {
         }
     };
 
-    public static final ObjectAllocator HTML_SAXPARSER_CONTEXT_ALLOCATOR = new ObjectAllocator() {
+    private static final ObjectAllocator HTML_SAXPARSER_CONTEXT_ALLOCATOR = new ObjectAllocator() {
         private HtmlSaxParserContext htmlSaxParserContext = null;
         public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
             if (htmlSaxParserContext == null) htmlSaxParserContext = new HtmlSaxParserContext(runtime, klazz);

data/ext/java/nokogiri/XmlAttr.java

@@ -79,22 +79,20 @@ public class XmlAttr extends XmlNode {
     @Override
     protected void init(ThreadContext context, IRubyObject[] args) {
         if (args.length < 2) {
-            throw getRuntime().newArgumentError(args.length, 2);
+            throw context.runtime.newArgumentError(args.length, 2);
         }
 
         IRubyObject doc = args[0];
         IRubyObject content = args[1];
 
-        if(!(doc instanceof XmlDocument)) {
-            final String msg =
-                "document must be an instance of Nokogiri::XML::Document";
-            throw getRuntime().newArgumentError(msg);
+        if (!(doc instanceof XmlDocument)) {
+            throw context.runtime.newArgumentError("document must be an instance of Nokogiri::XML::Document");
         }
 
         XmlDocument xmlDoc = (XmlDocument)doc;
         String str = rubyStringToString(content);
         Node attr = xmlDoc.getDocument().createAttribute(str);
-        setNode(context, attr);
+        setNode(context.runtime, attr);
     }
     
     
@@ -103,20 +101,10 @@ public class XmlAttr extends XmlNode {
     // the default namespace should be registered for this attribute
     void setNamespaceIfNecessary(Ruby runtime) {
         if ("xml".equals(node.getPrefix())) {
-           XmlNamespace.createDefaultNamespace(runtime, node); 
+            XmlNamespace.createDefaultNamespace(runtime, node);
         }
     }
 
-    private boolean isHtmlBooleanAttr() {
-        String name = node.getNodeName().toLowerCase();
-
-        for(String s : HTML_BOOLEAN_ATTRS) {
-            if(s.equals(name)) return true;
-        }
-
-        return false;
-    }
-
     @Override
     @JRubyMethod(name = {"content", "value", "to_s"})
     public IRubyObject content(ThreadContext context) {
@@ -140,11 +128,16 @@ public class XmlAttr extends XmlNode {
     @Override
     protected IRubyObject getNodeName(ThreadContext context) {
         if (name != null) return name;
-        String attrName = ((Attr)node).getName();
-        if (!(doc instanceof HtmlDocument) && node.getNamespaceURI() != null) {
+
+        String attrName = ((Attr) node).getName();
+        if (attrName == null) return context.nil;
+
+        if (node.getNamespaceURI() != null && !(document(context.runtime) instanceof HtmlDocument)) {
             attrName = NokogiriHelpers.getLocalPart(attrName);
+            if (attrName == null) return context.nil;
         }
-        return attrName == null ? context.getRuntime().getNil() : RubyString.newString(context.getRuntime(), attrName);
+
+        return name = RubyString.newString(context.runtime, attrName);
     }
 
     @Override

data/ext/java/nokogiri/XmlAttributeDecl.java

@@ -67,12 +67,11 @@ public class XmlAttributeDecl extends XmlNode {
         super(ruby, klass, attrDeclNode);
     }
 
-    public static IRubyObject create(ThreadContext context, Node attrDeclNode) {
-        XmlAttributeDecl self =
-            new XmlAttributeDecl(context.getRuntime(),
-                                 getNokogiriClass(context.getRuntime(), "Nokogiri::XML::AttributeDecl"),
-                                 attrDeclNode);
-        return self;
+    static XmlAttributeDecl create(ThreadContext context, Node attrDeclNode) {
+        return new XmlAttributeDecl(context.runtime,
+            getNokogiriClass(context.runtime, "Nokogiri::XML::AttributeDecl"),
+            attrDeclNode
+        );
     }
 
     @Override
@@ -84,8 +83,7 @@ public class XmlAttributeDecl extends XmlNode {
     @Override
     @JRubyMethod(name = "node_name=")
     public IRubyObject node_name_set(ThreadContext context, IRubyObject name) {
-        throw context.getRuntime()
-            .newRuntimeError("cannot change name of DTD decl");
+        throw context.runtime.newRuntimeError("cannot change name of DTD decl");
     }
 
     public IRubyObject element_name(ThreadContext context) {
@@ -112,19 +110,20 @@ public class XmlAttributeDecl extends XmlNode {
      */
     @JRubyMethod
     public IRubyObject enumeration(ThreadContext context) {
-        RubyArray enumVals = RubyArray.newArray(context.getRuntime());
-        String atype = ((Element)node).getAttribute("atype");
+        final String atype = ((Element) node).getAttribute("atype");
 
         if (atype != null && atype.length() != 0 && atype.charAt(0) == '(') {
             // removed enclosing parens
             String valueStr = atype.substring(1, atype.length() - 1);
             String[] values = valueStr.split("\\|");
+            RubyArray enumVals = RubyArray.newArray(context.runtime, values.length);
             for (int i = 0; i < values.length; i++) {
-                enumVals.append(context.getRuntime().newString(values[i]));
+                enumVals.append(context.runtime.newString(values[i]));
             }
+            return enumVals;
         }
 
-        return enumVals;
+        return context.runtime.newEmptyArray();
     }
 
 }

data/ext/java/nokogiri/XmlCdata.java

@@ -69,10 +69,9 @@ public class XmlCdata extends XmlText {
         }
         IRubyObject doc = args[0];
         content = args[1];
-        XmlDocument xmlDoc =(XmlDocument) ((XmlNode) doc).document(context);
-        Document document = xmlDoc.getDocument();
-        Node node = document.createCDATASection((content.isNil()) ? null : rubyStringToString(content));
-        setNode(context, node);
+        Document document = ((XmlNode) doc).getOwnerDocument();
+        Node node = document.createCDATASection(rubyStringToString(content));
+        setNode(context.runtime, node);
     }
 
     @Override

data/ext/java/nokogiri/XmlComment.java

@@ -82,7 +82,7 @@ public class XmlComment extends XmlNode {
         if (xmlDoc != null) {
             Document document = xmlDoc.getDocument();
             Node node = document.createComment(rubyStringToString(text));
-            setNode(context, node);
+            setNode(context.runtime, node);
         }
     }
 

data/ext/java/nokogiri/XmlDocument.java

@@ -39,25 +39,28 @@ import static nokogiri.internals.NokogiriHelpers.isNamespace;
 import static nokogiri.internals.NokogiriHelpers.rubyStringToString;
 import static nokogiri.internals.NokogiriHelpers.stringOrNil;
 
-import java.io.UnsupportedEncodingException;
 import java.util.List;
 
 import javax.xml.parsers.DocumentBuilderFactory;
 import javax.xml.parsers.ParserConfigurationException;
 
+import org.jcodings.specific.USASCIIEncoding;
+import org.jcodings.specific.UTF8Encoding;
 import org.jruby.Ruby;
 import org.jruby.RubyArray;
 import org.jruby.RubyClass;
 import org.jruby.RubyFixnum;
-import org.jruby.RubyNil;
+import org.jruby.RubyString;
 import org.jruby.anno.JRubyClass;
 import org.jruby.anno.JRubyMethod;
+import org.jruby.exceptions.RaiseException;
 import org.jruby.javasupport.JavaUtil;
-import org.jruby.runtime.Arity;
 import org.jruby.runtime.Block;
 import org.jruby.runtime.Helpers;
 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.DocumentType;
@@ -95,41 +98,43 @@ public class XmlDocument extends XmlNode {
      */
     private static final String DOCUMENTBUILDERFACTORY_IMPLE_NAME = "org.apache.xerces.jaxp.DocumentBuilderFactoryImpl";
 
+    private static final ByteList DOCUMENT = ByteList.create("document");
+    static { DOCUMENT.setEncoding(USASCIIEncoding.INSTANCE); }
+
     private static boolean substituteEntities = false;
     private static boolean loadExternalSubset = false; // TODO: Verify this.
 
     /** cache variables */
-    protected IRubyObject encoding = null;
-    protected IRubyObject url = null;
+    protected IRubyObject encoding;
+    protected IRubyObject url;
 
-    public XmlDocument(Ruby ruby, RubyClass klazz) {
-        super(ruby, klazz, createNewDocument());
+    public XmlDocument(Ruby runtime, RubyClass klazz) {
+        super(runtime, klazz, createNewDocument(runtime));
     }
 
-    public XmlDocument(Ruby ruby, Document document) {
-        this(ruby, getNokogiriClass(ruby, "Nokogiri::XML::Document"), document);
+    public XmlDocument(Ruby runtime, Document document) {
+        this(runtime, getNokogiriClass(runtime, "Nokogiri::XML::Document"), document);
     }
 
-    public XmlDocument(Ruby ruby, RubyClass klass, Document document) {
-        super(ruby, klass, document);
-        initializeNamespaceCacheIfNecessary();
-        createAndCacheNamespaces(ruby, document.getDocumentElement());
-        stabilizeTextContent(document);
-        setInstanceVariable("@decorators", ruby.getNil());
+    public XmlDocument(Ruby runtime, RubyClass klass, Document document) {
+        super(runtime, klass, document);
+        init(runtime, document);
     }
 
-    public void setDocumentNode(ThreadContext context, Node node) {
-        super.setNode(context, node);
-        initializeNamespaceCacheIfNecessary();
-        Ruby runtime = context.getRuntime();
-        if (node != null) {
-            Document document = (Document)node;
-            stabilizeTextContent(document);
+    void init(Ruby runtime, Document document) {
+        stabilizeTextContent(document);
+        if (document.getDocumentElement() != null) {
             createAndCacheNamespaces(runtime, document.getDocumentElement());
         }
         setInstanceVariable("@decorators", runtime.getNil());
     }
 
+    public final void setDocumentNode(Ruby runtime, Document node) {
+        super.setNode(runtime, node);
+        if (node != null) init(runtime, node);
+        else setInstanceVariable("@decorators", runtime.getNil());
+    }
+
     public void setEncoding(IRubyObject encoding) {
         this.encoding = encoding;
     }
@@ -141,72 +146,64 @@ public class XmlDocument extends XmlNode {
     // not sure, but like attribute values, text value will be lost
     // unless it is referred once before this document is used.
     // this seems to happen only when the fragment is parsed from Node#in_context.
-    protected void stabilizeTextContent(Document document) {
+    protected static void stabilizeTextContent(Document document) {
         if (document.getDocumentElement() != null) document.getDocumentElement().getTextContent();
     }
 
-    private void createAndCacheNamespaces(Ruby ruby, Node node) {
-        if (node == null) return;
+    private static void createAndCacheNamespaces(Ruby runtime, Node node) {
         if (node.hasAttributes()) {
             NamedNodeMap nodeMap = node.getAttributes();
             for (int i=0; i<nodeMap.getLength(); i++) {
                 Node n = nodeMap.item(i);
                 if (n instanceof Attr) {
-                    Attr attr = (Attr)n;
-                    String attrName = attr.getName();
-                    // not sure, but need to get value always before document is referred.
-                    // or lose attribute value
-                    String attrValue = attr.getValue(); // don't delete this line
-                    if (isNamespace(attrName)) {
+                    Attr attr = (Attr) n;
+                    stabilizeAttr(attr);
+                    if (isNamespace(attr.getName())) {
                         // create and cache
-                        XmlNamespace.createFromAttr(ruby, attr);
+                        XmlNamespace.createFromAttr(runtime, attr);
                     }
                 }
             }
         }
         NodeList children = node.getChildNodes();
         for (int i=0; i<children.getLength(); i++) {
-            createAndCacheNamespaces(ruby, children.item(i));
+            createAndCacheNamespaces(runtime, children.item(i));
         }
     }
 
+    static void stabilizeAttr(final Attr attr) {
+        // TODO not sure, but need to get value always before document is referred or lose attribute value
+        attr.getValue(); // don't delete this line
+    }
+
     // When a document is created from fragment with a context (reference) document,
     // namespace should be resolved based on the context document.
     public XmlDocument(Ruby ruby, RubyClass klass, Document document, XmlDocument contextDoc) {
         super(ruby, klass, document);
         nsCache = contextDoc.getNamespaceCache();
-        XmlNamespace default_ns = nsCache.getDefault();
-        String default_href = rubyStringToString(default_ns.href(ruby.getCurrentContext()));
-        resolveNamespaceIfNecessary(ruby.getCurrentContext(), document.getDocumentElement(), default_href);
+        String default_href = nsCache.getDefault().getHref();
+        resolveNamespaceIfNecessary(document.getDocumentElement(), default_href);
     }
 
-    private void resolveNamespaceIfNecessary(ThreadContext context, Node node, String default_href) {
+    private void resolveNamespaceIfNecessary(Node node, String default_href) {
         if (node == null) return;
         String nodePrefix = node.getPrefix();
         if (nodePrefix == null) { // default namespace
             NokogiriHelpers.renameNode(node, default_href, node.getNodeName());
         } else {
-            XmlNamespace xmlNamespace = nsCache.get(node, nodePrefix);
-            String href = rubyStringToString(xmlNamespace.href(context));
+            String href = getNamespaceCache().get(node, nodePrefix).getHref();
             NokogiriHelpers.renameNode(node, href, node.getNodeName());
         }
-        resolveNamespaceIfNecessary(context, node.getNextSibling(), default_href);
+        resolveNamespaceIfNecessary(node.getNextSibling(), default_href);
         NodeList children = node.getChildNodes();
         for (int i=0; i<children.getLength(); i++) {
-            resolveNamespaceIfNecessary(context, children.item(i), default_href);
+            resolveNamespaceIfNecessary(children.item(i), default_href);
         }
     }
 
     public NokogiriNamespaceCache getNamespaceCache() {
-        return nsCache;
-    }
-
-    public void initializeNamespaceCacheIfNecessary() {
         if (nsCache == null) nsCache = new NokogiriNamespaceCache();
-    }
-
-    public void setNamespaceCache(NokogiriNamespaceCache nsCache) {
-        this.nsCache = nsCache;
+        return nsCache;
     }
 
     public Document getDocument() {
@@ -215,7 +212,7 @@ public class XmlDocument extends XmlNode {
 
     @Override
     protected IRubyObject getNodeName(ThreadContext context) {
-        if (name == null) name = context.getRuntime().newString("document");
+        if (name == null) name = RubyString.newStringShared(context.runtime, DOCUMENT);
         return name;
     }
 
@@ -232,15 +229,31 @@ public class XmlDocument extends XmlNode {
         return getUrl();
     }
 
-    public static Document createNewDocument() {
+    public static Document createNewDocument(final Ruby runtime) {
         try {
-            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(DOCUMENTBUILDERFACTORY_IMPLE_NAME, NokogiriService.class.getClassLoader());
-            return factory.newDocumentBuilder().newDocument();
+            return DocumentBuilderFactoryHolder.INSTANCE.newDocumentBuilder().newDocument();
         } catch (ParserConfigurationException e) {
-            return null;        // this will end is disaster...
+            throw asRuntimeError(runtime, null, e);
         }
     }
 
+    private static class DocumentBuilderFactoryHolder {
+        static final DocumentBuilderFactory INSTANCE;
+        static {
+            INSTANCE = DocumentBuilderFactory.newInstance(DOCUMENTBUILDERFACTORY_IMPLE_NAME, NokogiriService.class.getClassLoader());
+        }
+    }
+
+    static RaiseException asRuntimeError(Ruby runtime, String message, Exception cause) {
+        if (cause instanceof RaiseException) return (RaiseException) cause;
+
+        if (message == null) message = cause.toString();
+        else message = message + '(' + cause.toString() + ')';
+        RaiseException ex = runtime.newRuntimeError(message);
+        ex.initCause(cause);
+        return ex;
+    }
+
     /*
      * call-seq:
      *  new(version = default)
@@ -249,19 +262,17 @@ public class XmlDocument extends XmlNode {
      */
     @JRubyMethod(name="new", meta = true, rest = true, required=0)
     public static IRubyObject rbNew(ThreadContext context, IRubyObject klazz, IRubyObject[] args) {
+        final Ruby runtime = context.runtime;
         XmlDocument xmlDocument;
         try {
-            Document docNode = createNewDocument();
+            Document docNode = createNewDocument(runtime);
             if ("Nokogiri::HTML::Document".equals(((RubyClass)klazz).getName())) {
-                xmlDocument = (XmlDocument) NokogiriService.HTML_DOCUMENT_ALLOCATOR.allocate(context.getRuntime(), (RubyClass) klazz);
-                xmlDocument.setDocumentNode(context, docNode);
+                xmlDocument = new HtmlDocument(context.runtime, (RubyClass) klazz, docNode);
             } else {
-                // XML::Document and sublass
-                xmlDocument = (XmlDocument) NokogiriService.XML_DOCUMENT_ALLOCATOR.allocate(context.getRuntime(), (RubyClass) klazz);
-                xmlDocument.setDocumentNode(context, docNode);
+                xmlDocument = new XmlDocument(context.runtime, (RubyClass) klazz, docNode);
             }
         } catch (Exception ex) {
-            throw context.getRuntime().newRuntimeError("couldn't create document: "+ex.toString());
+            throw asRuntimeError(runtime, "couldn't create document: ", ex);
         }
 
         Helpers.invoke(context, xmlDocument, "initialize", args);
@@ -274,19 +285,19 @@ public class XmlDocument extends XmlNode {
         // FIXME: Entity node should be create by some right way.
         // this impl passes tests, but entity doesn't exists in DTD, which
         // would cause validation failure.
-        if (argv.length == 0) throw context.getRuntime().newRuntimeError("Could not create entity");
+        if (argv.length == 0) throw context.runtime.newRuntimeError("Could not create entity");
         String tagName = rubyStringToString(argv[0]);
-        Node n = this.getOwnerDocument().createElement(tagName);
-        return XmlEntityDecl.create(context, n, argv);
+        Node node = getOwnerDocument().createElement(tagName);
+        return XmlEntityDecl.create(context, node, argv);
     }
 
     @Override
-    IRubyObject document(Ruby runtime) {
+    XmlDocument document(Ruby runtime) {
         return this;
     }
 
     @JRubyMethod(name="encoding=")
-    public IRubyObject encoding_set(ThreadContext context, IRubyObject encoding) {
+    public IRubyObject encoding_set(IRubyObject encoding) {
         this.encoding = encoding;
         return this;
     }
@@ -294,10 +305,11 @@ public class XmlDocument extends XmlNode {
     @JRubyMethod
     public IRubyObject encoding(ThreadContext context) {
         if (this.encoding == null || this.encoding.isNil()) {
-            if (getDocument().getXmlEncoding() == null) {
-                this.encoding = context.getRuntime().getNil();
+            final String enc = getDocument().getXmlEncoding();
+            if (enc == null) {
+                this.encoding = context.nil;
             } else {
-                this.encoding = context.getRuntime().newString(getDocument().getXmlEncoding());
+                this.encoding = context.runtime.newString(enc);
             }
         }
 
@@ -307,59 +319,32 @@ public class XmlDocument extends XmlNode {
     @JRubyMethod(meta = true)
     public static IRubyObject load_external_subsets_set(ThreadContext context, IRubyObject cls, IRubyObject value) {
         XmlDocument.loadExternalSubset = value.isTrue();
-        return context.getRuntime().getNil();
-    }
-
-    /**
-     * TODO: handle encoding?
-     *
-     * @param args[0] a Ruby IO or StringIO
-     * @param args[1] url or nil
-     * @param args[2] encoding
-     * @param args[3] bitset of parser options
-     */
-    public static IRubyObject newFromData(ThreadContext context,
-                                          IRubyObject klass,
-                                          IRubyObject[] args) {
-        Ruby ruby = context.getRuntime();
-        Arity.checkArgumentCount(ruby, args, 4, 4);
-        XmlDomParserContext ctx =
-            new XmlDomParserContext(ruby, args[2], args[3]);
-        ctx.setInputSource(context, args[0], args[1]);
-        return ctx.parse(context, klass, args[1]);
-    }
-
-    @JRubyMethod(meta = true, rest = true)
-    public static IRubyObject read_io(ThreadContext context,
-                                      IRubyObject klass,
-                                      IRubyObject[] args) {
-        return newFromData(context, klass, args);
+        return context.nil;
     }
 
-    @JRubyMethod(meta = true, rest = true)
-    public static IRubyObject read_memory(ThreadContext context,
-                                          IRubyObject klass,
-                                          IRubyObject[] args) {
-        return newFromData(context, klass, args);
+    @JRubyMethod(meta = true, required = 4)
+    public static IRubyObject read_io(ThreadContext context, IRubyObject klass, IRubyObject[] args) {
+        XmlDomParserContext ctx = new XmlDomParserContext(context.runtime, args[2], args[3]);
+        ctx.setIOInputSource(context, args[0], args[1]);
+        return ctx.parse(context, (RubyClass) klass, args[1]);
     }
 
-    /** not a JRubyMethod */
-    public static IRubyObject read_memory(ThreadContext context,
-                                          IRubyObject[] args) {
-        return read_memory(context,
-                           getNokogiriClass(context.getRuntime(), "Nokogiri::XML::Document"),
-                           args);
+    @JRubyMethod(meta = true, required = 4)
+    public static IRubyObject read_memory(ThreadContext context, IRubyObject klass, IRubyObject[] args) {
+        XmlDomParserContext ctx = new XmlDomParserContext(context.runtime, args[2], args[3]);
+        ctx.setStringInputSource(context, args[0], args[1]);
+        return ctx.parse(context, (RubyClass) klass, args[1]);
     }
 
     @JRubyMethod(name="remove_namespaces!")
     public IRubyObject remove_namespaces(ThreadContext context) {
-        removeNamespceRecursively(context, this);
-        nsCache.clear();
+        removeNamespaceRecursively(this);
+        if (nsCache != null) nsCache.clear();
         clearXpathContext(getNode());
         return this;
     }
 
-    private void removeNamespceRecursively(ThreadContext context, XmlNode xmlNode) {
+    private void removeNamespaceRecursively(XmlNode xmlNode) {
         Node node = xmlNode.node;
         if (node.getNodeType() == Node.ELEMENT_NODE) {
             node.setPrefix(null);
@@ -368,33 +353,29 @@ public class XmlDocument extends XmlNode {
             for (int i=0; i<attrs.getLength(); i++) {
                 Attr attr = (Attr) attrs.item(i);
                 if (isNamespace(attr.getNodeName())) {
-                    ((org.w3c.dom.Element)node).removeAttributeNode(attr);
+                    ((org.w3c.dom.Element) node).removeAttributeNode(attr);
                 } else {
                     attr.setPrefix(null);
                     NokogiriHelpers.renameNode(attr, null, attr.getLocalName());
                 }
             }
         }
-        XmlNodeSet nodeSet = (XmlNodeSet) xmlNode.children(context);
-        for (long i=0; i < nodeSet.length(); i++) {
-            XmlNode childNode = (XmlNode)nodeSet.slice(context, RubyFixnum.newFixnum(context.getRuntime(), i));
-            removeNamespceRecursively(context, childNode);
+        IRubyObject[] nodes = xmlNode.getChildren();
+        for (int i=0; i < nodes.length; i++) {
+            XmlNode childNode = (XmlNode) nodes[i];
+            removeNamespaceRecursively(childNode);
         }
     }
 
     @JRubyMethod
     public IRubyObject root(ThreadContext context) {
         Node rootNode = getDocument().getDocumentElement();
-        try {
-            Boolean isValid = (Boolean)rootNode.getUserData(NokogiriHelpers.VALID_ROOT_NODE);
-            if (!isValid) return context.getRuntime().getNil();
-        } catch (NullPointerException e) {
-            // does nothing since nil wasn't set to the root node before.
-        }
-        if (rootNode == null)
-            return context.getRuntime().getNil();
-        else
-            return getCachedNodeOrCreate(context.getRuntime(), rootNode);
+        if (rootNode == null) return context.nil;
+
+        Object invalid = rootNode.getUserData(NokogiriHelpers.ROOT_NODE_INVALID);
+        if (invalid != null && ((Boolean) invalid)) return context.nil;
+
+        return getCachedNodeOrCreate(context.runtime, rootNode);
     }
 
     protected IRubyObject dup_implementation(Ruby runtime, boolean deep) {
@@ -412,17 +393,17 @@ public class XmlDocument extends XmlNode {
     }
 
     @JRubyMethod(name="root=")
-    public IRubyObject root_set(ThreadContext context, IRubyObject newRoot_) {
+    public IRubyObject root_set(ThreadContext context, IRubyObject new_root) {
         // in case of document fragment, temporary root node should be deleted.
 
         // Java can't have a root whose value is null. Instead of setting null,
         // the method sets user data so that other methods are able to know the root
         // should be nil.
-        if (newRoot_ instanceof RubyNil) {
-            getDocument().getDocumentElement().setUserData(NokogiriHelpers.VALID_ROOT_NODE, false, null);
-            return newRoot_;
+        if (new_root == context.nil) {
+            getDocument().getDocumentElement().setUserData(NokogiriHelpers.ROOT_NODE_INVALID, Boolean.TRUE, null);
+            return new_root;
         }
-        XmlNode newRoot = asXmlNode(context, newRoot_);
+        XmlNode newRoot = asXmlNode(context, new_root);
 
         IRubyObject root = root(context);
         if (root.isNil()) {
@@ -434,10 +415,10 @@ public class XmlDocument extends XmlNode {
                 // with different owner document.
                 newRootNode = getDocument().importNode(newRoot.node, true);
             }
-            add_child_node(context, getCachedNodeOrCreate(context.getRuntime(), newRootNode));
+            add_child_node(context, getCachedNodeOrCreate(context.runtime, newRootNode));
         } else {
             Node rootNode = asXmlNode(context, root).node;
-            ((XmlNode)getCachedNodeOrCreate(context.getRuntime(), rootNode)).replace_node(context, newRoot);
+            ((XmlNode) getCachedNodeOrCreate(context.runtime, rootNode)).replace_node(context, newRoot);
         }
 
         return newRoot;
@@ -445,13 +426,13 @@ public class XmlDocument extends XmlNode {
 
     @JRubyMethod
     public IRubyObject version(ThreadContext context) {
-        return stringOrNil(context.getRuntime(), getDocument().getXmlVersion());
+        return stringOrNil(context.runtime, getDocument().getXmlVersion());
     }
 
     @JRubyMethod(meta = true)
     public static IRubyObject substitute_entities_set(ThreadContext context, IRubyObject cls, IRubyObject value) {
         XmlDocument.substituteEntities = value.isTrue();
-        return context.getRuntime().getNil();
+        return context.nil;
     }
 
     public IRubyObject getInternalSubset(ThreadContext context) {
@@ -460,27 +441,23 @@ public class XmlDocument extends XmlNode {
         if (dtd == null) {
             Document document = getDocument();
             if (document.getUserData(XmlDocument.DTD_RAW_DOCUMENT) != null) {
-                dtd = XmlDtd.newFromInternalSubset(context.getRuntime(), document);
+                dtd = XmlDtd.newFromInternalSubset(context.runtime, document);
             } else if (document.getDoctype() != null) {
                 DocumentType docType = document.getDoctype();
                 IRubyObject name, publicId, systemId;
-                name = publicId = systemId = context.getRuntime().getNil();
+                name = publicId = systemId = context.nil;
                 if (docType.getName() != null) {
-                    name = context.getRuntime().newString(docType.getName());
+                    name = context.runtime.newString(docType.getName());
                 }
                 if (docType.getPublicId() != null) {
-                    publicId = context.getRuntime().newString(docType.getPublicId());
+                    publicId = context.runtime.newString(docType.getPublicId());
                 }
                 if (docType.getSystemId() != null) {
-                    systemId = context.getRuntime().newString(docType.getSystemId());
+                    systemId = context.runtime.newString(docType.getSystemId());
                 }
-                dtd = XmlDtd.newEmpty(context.getRuntime(),
-                                      document,
-                                      name,
-                                      publicId,
-                                      systemId);
+                dtd = XmlDtd.newEmpty(context.runtime, document, name, publicId, systemId);
             } else {
-                dtd = context.getRuntime().getNil();
+                dtd = context.nil;
             }
 
             setInternalSubset(dtd);
@@ -497,9 +474,7 @@ public class XmlDocument extends XmlNode {
                                             IRubyObject name,
                                             IRubyObject external_id,
                                             IRubyObject system_id) {
-        XmlDtd dtd = XmlDtd.newEmpty(context.getRuntime(),
-                                     this.getDocument(),
-                                     name, external_id, system_id);
+        XmlDtd dtd = XmlDtd.newEmpty(context.runtime, getDocument(), name, external_id, system_id);
         setInternalSubset(dtd);
         return dtd;
     }
@@ -511,7 +486,7 @@ public class XmlDocument extends XmlNode {
     public IRubyObject getExternalSubset(ThreadContext context) {
         IRubyObject dtd = (IRubyObject) node.getUserData(DTD_EXTERNAL_SUBSET);
 
-        if (dtd == null) return context.getRuntime().getNil();
+        if (dtd == null) return context.nil;
         return dtd;
     }
 
@@ -523,9 +498,7 @@ public class XmlDocument extends XmlNode {
                                             IRubyObject name,
                                             IRubyObject external_id,
                                             IRubyObject system_id) {
-        XmlDtd dtd = XmlDtd.newEmpty(context.getRuntime(),
-                                     this.getDocument(),
-                                     name, external_id, system_id);
+        XmlDtd dtd = XmlDtd.newEmpty(context.runtime, getDocument(), name, external_id, system_id);
         setExternalSubset(dtd);
         return dtd;
     }
@@ -543,35 +516,40 @@ public class XmlDocument extends XmlNode {
             Node child = children.item(i);
             short type = child.getNodeType();
             if (type == Node.COMMENT_NODE) {
-                XmlComment xmlComment = (XmlComment) getCachedNodeOrCreate(context.getRuntime(), child);
+                XmlComment xmlComment = (XmlComment) getCachedNodeOrCreate(context.runtime, child);
                 xmlComment.accept(context, visitor);
             } else if (type == Node.DOCUMENT_TYPE_NODE) {
-                XmlDtd xmlDtd = (XmlDtd) getCachedNodeOrCreate(context.getRuntime(), child);
+                XmlDtd xmlDtd = (XmlDtd) getCachedNodeOrCreate(context.runtime, child);
                 xmlDtd.accept(context, visitor);
             } else if (type == Node.PROCESSING_INSTRUCTION_NODE) {
-                XmlProcessingInstruction xmlProcessingInstruction = (XmlProcessingInstruction) getCachedNodeOrCreate(context.getRuntime(), child);
+                XmlProcessingInstruction xmlProcessingInstruction = (XmlProcessingInstruction) getCachedNodeOrCreate(context.runtime, child);
                 xmlProcessingInstruction.accept(context, visitor);
             } else if (type == Node.TEXT_NODE) {
-                XmlText xmlText = (XmlText) getCachedNodeOrCreate(context.getRuntime(), child);
+                XmlText xmlText = (XmlText) getCachedNodeOrCreate(context.runtime, child);
                 xmlText.accept(context, visitor);
             } else if (type == Node.ELEMENT_NODE) {
-                XmlElement xmlElement = (XmlElement) getCachedNodeOrCreate(context.getRuntime(), child);
+                XmlElement xmlElement = (XmlElement) getCachedNodeOrCreate(context.runtime, child);
                 xmlElement.accept(context, visitor);
             }
         }
         visitor.leave(document);
     }
 
-    @JRubyMethod(meta=true)
-    public static IRubyObject wrapJavaDocument(ThreadContext context, IRubyObject klazz, IRubyObject arg) {
-        XmlDocument xmlDocument = (XmlDocument) NokogiriService.XML_DOCUMENT_ALLOCATOR.allocate(context.getRuntime(), getNokogiriClass(context.getRuntime(), "Nokogiri::XML::Document"));
+    @JRubyMethod(meta = true)
+    public static IRubyObject wrap(ThreadContext context, IRubyObject klass, IRubyObject arg) {
+        XmlDocument xmlDocument = new XmlDocument(context.runtime, (RubyClass) klass, (Document) arg.toJava(Document.class));
         Helpers.invoke(context, xmlDocument, "initialize");
-        Document document = (Document)arg.toJava(Document.class);
-        xmlDocument.setDocumentNode(context, document);
         return xmlDocument;
     }
 
-    @JRubyMethod
+    @Deprecated
+    @JRubyMethod(meta = true, visibility = Visibility.PRIVATE)
+    public static IRubyObject wrapJavaDocument(ThreadContext context, IRubyObject klass, IRubyObject arg) {
+        return wrap(context, klass, arg);
+    }
+
+    @Deprecated // default to_java works (due inherited from XmlNode#toJava)
+    @JRubyMethod(visibility = Visibility.PRIVATE)
     public IRubyObject toJavaDocument(ThreadContext context) {
         return JavaUtil.convertJavaToUsableRubyObject(context.getRuntime(), node);
     }
@@ -596,11 +574,11 @@ public class XmlDocument extends XmlNode {
         }
         if (args.length > 1 ) {
             if (!args[1].isNil() && !(args[1] instanceof List)) {
-                throw context.getRuntime().newTypeError("Expected array");
+                throw context.runtime.newTypeError("Expected array");
             }
             if (!args[1].isNil()) {
               inclusive_namespace = ((RubyArray)args[1])
-                .join(context, context.getRuntime().newString(" "))
+                .join(context, context.runtime.newString(" "))
                 .asString()
                 .asJavaString(); // OMG I wish I knew JRuby better, this is ugly
             }
@@ -632,29 +610,24 @@ public class XmlDocument extends XmlNode {
             } else {
                 result = canonicalizer.canonicalizeSubtree(startingNode.getNode(), inclusive_namespace, filter);
             }
-            String resultString = new String(result, "UTF-8");
-            return stringOrNil(context.getRuntime(), resultString);
+            return RubyString.newString(context.runtime, new ByteList(result, UTF8Encoding.INSTANCE));
         } catch (CanonicalizationException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
-        } catch (UnsupportedEncodingException e) {
-            // TODO Auto-generated catch block
-            e.printStackTrace();
         }
-        return context.getRuntime().getNil();
+        return context.nil;
     }
 
     private XmlNode getStartingNode(Block block) {
         if (block.isGiven()) {
-            if (block.getBinding().getSelf() instanceof XmlNode) {
-                return (XmlNode)block.getBinding().getSelf();
-            }
+            IRubyObject boundSelf = block.getBinding().getSelf();
+            if (boundSelf instanceof XmlNode) return (XmlNode) boundSelf;
         }
         return this;
     }
 
     public void resetNamespaceCache(ThreadContext context) {
         nsCache = new NokogiriNamespaceCache();
-        createAndCacheNamespaces(context.getRuntime(), node);
+        createAndCacheNamespaces(context.runtime, node);
     }
 }