nokogiri 1.7.2-java → 1.8.0-java

data/ext/java/nokogiri/XsltStylesheet.java

@@ -82,16 +82,12 @@ import org.w3c.dom.Document;
  */
 @JRubyClass(name="Nokogiri::XSLT::Stylesheet")
 public class XsltStylesheet extends RubyObject {
-    private static Map<String, Object> registry = new HashMap<String, Object>();
+
     private TransformerFactory factory = null;
     private Templates sheet = null;
     private IRubyObject stylesheet = null;
     private boolean htmlish = false;
 
-    public static Map<String, Object> getRegistry() {
-        return registry;
-    }
-
     public XsltStylesheet(Ruby ruby, RubyClass rubyClass) {
         super(ruby, rubyClass);
     }
@@ -215,8 +211,7 @@ public class XsltStylesheet extends RubyObject {
 
         NokogiriXsltErrorListener elistener = new NokogiriXsltErrorListener();
         DOMSource domSource = new DOMSource(((XmlDocument) args[0]).getDocument());
-        DOMResult result = null;
-        String stringResult = null;
+        final DOMResult result; String stringResult = null;
         try{
             result = tryXsltTransformation(context, args, domSource, elistener); // DOMResult
             if (result.getNode().getFirstChild() == null) {
@@ -275,16 +270,17 @@ public class XsltStylesheet extends RubyObject {
         pwriter.connect(preader);
         StreamResult result = new StreamResult(pwriter);
         transf.transform(domSource, result);
+
         char[] cbuf = new char[1024];
         int len = preader.read(cbuf, 0, 1024);
-        StringBuilder builder = new StringBuilder();
-        builder.append(CharBuffer.wrap(cbuf, 0, len));
-        htmlish = isHtml(builder.toString()); // judge from the first chunk
+        StringBuilder builder = new StringBuilder(len);
+        builder.append(cbuf, 0, len);
+        htmlish = isHtml(builder); // judge from the first chunk
         
         while (len == 1024) {
             len = preader.read(cbuf, 0, 1024);
             if (len > 0) {
-                builder.append(CharBuffer.wrap(cbuf, 0, len));
+                builder.append(cbuf, 0, len);
             }
         }
         
@@ -308,20 +304,18 @@ public class XsltStylesheet extends RubyObject {
     
     private Templates getTemplatesFromStreamSource() throws TransformerConfigurationException {
         if (stylesheet instanceof RubyString) {
-            StringReader reader = new StringReader((String)stylesheet.toJava(String.class));
+            StringReader reader = new StringReader(stylesheet.asJavaString());
             StreamSource xsltStreamSource = new StreamSource(reader);
             return factory.newTemplates(xsltStreamSource);
         }
         return null;
     }
     
-    private static Pattern html_tag = 
-        Pattern.compile("<(%s)*html", Pattern.CASE_INSENSITIVE);
+    private static final Pattern HTML_TAG = Pattern.compile("<(%s)*html", Pattern.CASE_INSENSITIVE);
     
-    private boolean isHtml(String chunk) {  
-        Matcher m = XsltStylesheet.html_tag.matcher(chunk);
-        if (m.find()) return true;
-        else return false;
+    private static boolean isHtml(CharSequence chunk) {
+        Matcher match = HTML_TAG.matcher(chunk);
+        return match.find();
     }
     
     private IRubyObject createDocumentFromString(ThreadContext context, Ruby runtime, String stringResult) {
@@ -346,12 +340,9 @@ public class XsltStylesheet extends RubyObject {
         }
     }
     
-    private void argumentTypeCheck(Ruby runtime, IRubyObject arg) {
-        if (arg instanceof XmlDocument) {
-            return;
-        } else {
-            throw runtime.newArgumentError("argument must be a Nokogiri::XML::Document");
-        }
+    private static void argumentTypeCheck(Ruby runtime, IRubyObject arg) {
+        if (arg instanceof XmlDocument) return;
+        throw runtime.newArgumentError("argument must be a Nokogiri::XML::Document");
     }
     
     @JRubyMethod(name = {"registr", "register"}, meta = true)

data/ext/java/nokogiri/internals/HtmlDomParserContext.java

@@ -39,7 +39,6 @@ import nokogiri.HtmlDocument;
 import nokogiri.NokogiriService;
 import nokogiri.XmlDocument;
 
-import org.apache.xerces.parsers.DOMParser;
 import org.apache.xerces.xni.Augmentations;
 import org.apache.xerces.xni.QName;
 import org.apache.xerces.xni.XMLAttributes;
@@ -54,6 +53,7 @@ import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.w3c.dom.Document;
 import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
 import org.w3c.dom.NodeList;
 
 /**
@@ -65,8 +65,6 @@ import org.w3c.dom.NodeList;
  */
 public class HtmlDomParserContext extends XmlDomParserContext {
 
-    private String encoding;
-
 	public HtmlDomParserContext(Ruby runtime, IRubyObject options) {
         super(runtime, options);
     }
@@ -87,7 +85,7 @@ public class HtmlDomParserContext extends XmlDomParserContext {
     @Override
     protected void initParser(Ruby runtime) {
         XMLParserConfiguration config = new HTMLConfiguration();
-        XMLDocumentFilter removeNSAttrsFilter = new RemoveNSAttrsFilter();
+        //XMLDocumentFilter removeNSAttrsFilter = new RemoveNSAttrsFilter();
         XMLDocumentFilter elementValidityCheckFilter = new ElementValidityCheckFilter(errorHandler);
         //XMLDocumentFilter[] filters = { removeNSAttrsFilter,  elementValidityCheckFilter};
         XMLDocumentFilter[] filters = { elementValidityCheckFilter};
@@ -121,14 +119,12 @@ public class HtmlDomParserContext extends XmlDomParserContext {
 
     @Override
     protected XmlDocument getNewEmptyDocument(ThreadContext context) {
-        IRubyObject[] args = new IRubyObject[0];
+        IRubyObject[] args = IRubyObject.NULL_ARRAY;
         return (XmlDocument) XmlDocument.rbNew(context, getNokogiriClass(context.getRuntime(), "Nokogiri::HTML::Document"), args);
     }
 
     @Override
-    protected XmlDocument wrapDocument(ThreadContext context,
-                                       RubyClass klazz,
-                                       Document document) {
+    protected XmlDocument wrapDocument(ThreadContext context, RubyClass klazz, Document document) {
         HtmlDocument htmlDocument = (HtmlDocument) NokogiriService.HTML_DOCUMENT_ALLOCATOR.allocate(context.getRuntime(), klazz);
         htmlDocument.setDocumentNode(context, document);
         if (ruby_encoding.isNil()) {
@@ -149,18 +145,18 @@ public class HtmlDomParserContext extends XmlDomParserContext {
     // NekoHtml doesn't understand HTML5 meta tag format. This fails to detect charset
     // from an HTML5 style meta tag. Luckily, the meta tag and charset exists in DOM tree
     // so, this method attempts to find the charset.
-    private String tryGetCharsetFromHtml5MetaTag(Document document) {
+    private static String tryGetCharsetFromHtml5MetaTag(Document document) {
         if (!"html".equalsIgnoreCase(document.getDocumentElement().getNodeName())) return null;
-        NodeList list = document.getDocumentElement().getChildNodes();
+        NodeList list = document.getDocumentElement().getChildNodes(); Node item;
         for (int i = 0; i < list.getLength(); i++) {
-            if ("head".equalsIgnoreCase(list.item(i).getNodeName())) {
-                NodeList headers = list.item(i).getChildNodes();
+            if ("head".equalsIgnoreCase((item = list.item(i)).getNodeName())) {
+                NodeList headers = item.getChildNodes();
                 for (int j = 0; j < headers.getLength(); j++) {
-                    if ("meta".equalsIgnoreCase(headers.item(j).getNodeName())) {
-                        NamedNodeMap nodeMap = headers.item(j).getAttributes();
+                    if ("meta".equalsIgnoreCase((item = headers.item(j)).getNodeName())) {
+                        NamedNodeMap nodeMap = item.getAttributes();
                         for (int k = 0; k < nodeMap.getLength(); k++) {
-                            if ("charset".equalsIgnoreCase(nodeMap.item(k).getNodeName())) {
-                                return nodeMap.item(k).getNodeValue();
+                            if ("charset".equalsIgnoreCase((item = nodeMap.item(k)).getNodeName())) {
+                                return item.getNodeValue();
                             }
                         }
                     }
@@ -227,12 +223,12 @@ public class HtmlDomParserContext extends XmlDomParserContext {
                 {}  // z
         };
         
-        private boolean isValid(String testee) {
-            char[] c = testee.toCharArray();
-            int index = new Integer(c[0]) - 97;
-            if (index > 25) return false;
-            for (int i=0; i<element_names[index].length; i++) {
-                if (testee.equals(element_names[index][i])) {
+        private static boolean isValid(final String name) {
+            int index = name.charAt(0) - 97;
+            if (index >= element_names.length) return false;
+            String[] elementNames = element_names[index];
+            for (int i=0; i<elementNames.length; i++) {
+                if (name.equals(elementNames[i])) {
                     return true;
                 }
             }
@@ -242,7 +238,7 @@ public class HtmlDomParserContext extends XmlDomParserContext {
         @Override
         public void startElement(QName name, XMLAttributes attrs, Augmentations augs) throws XNIException {
             if (!isValid(name.rawname)) {
-                errorHandler.getErrors().add(new Exception("Tag " + name.rawname + " invalid"));
+                errorHandler.addError(new Exception("Tag " + name.rawname + " invalid"));
             }
             super.startElement(name, attrs, augs);
         }

data/ext/java/nokogiri/internals/NokogiriDomParser.java

@@ -99,7 +99,7 @@ public class NokogiriDomParser extends DOMParser {
         doc.setUserData(XmlDocument.DTD_RAW_DOCUMENT, dtd.getDocument(), null);
     }
 
-    private class NokogiriXInlcudeEntityResolver implements org.xml.sax.EntityResolver {
+    private static class NokogiriXInlcudeEntityResolver implements org.xml.sax.EntityResolver {
         InputSource source;
         private NokogiriXInlcudeEntityResolver(InputSource source) {
             this.source = source;

data/ext/java/nokogiri/internals/NokogiriEncodingReaderWrapper.java

@@ -41,7 +41,7 @@ public class NokogiriEncodingReaderWrapper extends InputStream {
     this.encodingReader = encodingReader;
     this.ruby = context.getRuntime();
 
-    if (!RuntimeHelpers.invoke(context, encodingReader, "respond_to?", ruby.newSymbol("read").to_sym()).isTrue()
+    if (!RuntimeHelpers.invoke(context, encodingReader, "respond_to?", ruby.newSymbol("read")).isTrue()
         || encodingReader.getInstanceVariable("@io") == null) {
       throw ruby.newArgumentError("Argument doesn't respond to read or doesn't have instance variable @io");
     }

data/ext/java/nokogiri/internals/NokogiriEntityResolver.java

@@ -19,7 +19,7 @@ import org.xml.sax.ext.EntityResolver2;
  * to be relative to the current directory of the Ruby runtime.
  */
 public class NokogiriEntityResolver implements EntityResolver2 {
-    protected Ruby runtime;
+    protected final Ruby runtime;
     private final NokogiriErrorHandler handler;
     private final Options options;
 
@@ -33,7 +33,7 @@ public class NokogiriEntityResolver implements EntityResolver2 {
     @Override
     public InputSource getExternalSubset(String name, String baseURI)
         throws SAXException, IOException {
-      return null;
+        return null;
     }
 
     @Override
@@ -51,17 +51,16 @@ public class NokogiriEntityResolver implements EntityResolver2 {
         return resolveEntity(runtime, name, publicId, baseURI, systemId);
     }
 
-    private File join(String parent, String child) {
-      if (new File(parent).isFile()) {
-        parent = new File(parent).getParent();
-      }
-
-      return new File(parent, child);
+    private static File join(String parent, String child) {
+        if (new File(parent).isFile()) {
+            parent = new File(parent).getParent();
+        }
+        return new File(parent, child);
     }
 
-    private InputSource emptyInputSource(InputSource source) {
-      source.setByteStream(new ByteArrayInputStream(new byte[0]));
-      return source;
+    private static InputSource emptyInputSource(InputSource source) {
+        source.setByteStream(new ByteArrayInputStream(new byte[0]));
+        return source;
     }
 
     private boolean shouldLoadDtd() {
@@ -69,8 +68,7 @@ public class NokogiriEntityResolver implements EntityResolver2 {
     }
 
     private void addError(String errorMessage) {
-      if (handler != null)
-        handler.errors.add(new Exception(errorMessage));
+        if (handler != null) handler.errors.add(new Exception(errorMessage));
     }
 
     /**

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

@@ -32,18 +32,10 @@
 
 package nokogiri.internals;
 
-import static nokogiri.internals.NokogiriHelpers.getNokogiriClass;
-
 import java.util.ArrayList;
 import java.util.List;
 
-import nokogiri.NokogiriService;
-import nokogiri.XmlSyntaxError;
-
 import org.apache.xerces.xni.parser.XMLErrorHandler;
-import org.jruby.Ruby;
-import org.jruby.runtime.ThreadContext;
-import org.jruby.runtime.builtin.IRubyObject;
 import org.xml.sax.ErrorHandler;
 
 /**
@@ -56,30 +48,22 @@ import org.xml.sax.ErrorHandler;
  * @author Yoko Harada <yokolet@gmail.com>
  */
 public abstract class NokogiriErrorHandler implements ErrorHandler, XMLErrorHandler {
-    protected List<Exception> errors;
+    protected final List<Exception> errors;
     protected boolean noerror;
     protected boolean nowarning;
 
     public NokogiriErrorHandler(boolean noerror, boolean nowarning) {
-        errors = new ArrayList<Exception>();
+        this.errors = new ArrayList<Exception>(4);
         this.noerror = noerror;
         this.nowarning = nowarning;
     }
 
-    public List<Exception> getErrors() { return errors; }
+    List<Exception> getErrors() { return errors; }
 
-    public List<IRubyObject> getErrorsReadyForRuby(ThreadContext context) {
-        Ruby runtime = context.getRuntime();
-        List<IRubyObject> res = new ArrayList<IRubyObject>();
-        for (int i = 0; i < errors.size(); i++) {
-            XmlSyntaxError xmlSyntaxError = (XmlSyntaxError) NokogiriService.XML_SYNTAXERROR_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::SyntaxError"));
-            xmlSyntaxError.setException(errors.get(i));
-            res.add(xmlSyntaxError);
-        }
-        return res;
-    }
+    public void addError(Exception ex) { errors.add(ex); }
 
     protected boolean usesNekoHtml(String domain) {
         return "http://cyberneko.org/html".equals(domain);
     }
+
 }

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

@@ -242,7 +242,7 @@ public class NokogiriHandler extends DefaultHandler2 implements XmlDeclHandler {
     @Override
     public void characters(char[] ch, int start, int length) throws SAXException {
         StringBuffer sb = characterStack.peek();
-        sb.append(new String(ch, start, length));
+        sb.append(ch, start, length);
     }
 
     @Override

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

@@ -32,17 +32,14 @@
 
 package nokogiri.internals;
 
+import java.io.ByteArrayInputStream;
 import java.io.File;
 import java.io.UnsupportedEncodingException;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.nio.ByteBuffer;
 import java.nio.CharBuffer;
-import java.nio.charset.CharacterCodingException;
 import java.nio.charset.Charset;
-import java.nio.charset.CharsetEncoder;
-import java.util.ArrayList;
-import java.util.List;
 import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -62,7 +59,6 @@ import nokogiri.XmlProcessingInstruction;
 import nokogiri.XmlText;
 import nokogiri.XmlXpathContext;
 
-import org.jcodings.specific.UTF8Encoding;
 import org.jruby.Ruby;
 import org.jruby.RubyArray;
 import org.jruby.RubyClass;
@@ -193,28 +189,28 @@ public class NokogiriHelpers {
         return NokogiriService.getNokogiriClassCache(ruby).get(name);
     }
 
-    public static IRubyObject stringOrNil(Ruby runtime, String s) {
-        if (s == null) return runtime.getNil();
-        return convertJavaStringToRuby(runtime, s);
+    public static IRubyObject stringOrNil(Ruby runtime, String str) {
+        return str == null ? runtime.getNil() : convertString(runtime, str);
     }
-    
+
+    public static IRubyObject stringOrNil(Ruby runtime, CharSequence str) {
+        return str == null ? runtime.getNil() : convertString(runtime, str);
+    }
+
     public static IRubyObject stringOrNil(Ruby runtime, byte[] bytes) {
-        if (bytes == null) return runtime.getNil();
-        return RubyString.newString(runtime, bytes);
+        return bytes == null ? runtime.getNil() : RubyString.newString(runtime, bytes);
     }
-    
-    public static IRubyObject stringOrBlank(Ruby runtime, String s) {
-        if (s == null) return runtime.newString();
-        return convertJavaStringToRuby(runtime, s);
+
+    public static IRubyObject stringOrBlank(Ruby runtime, String str) {
+        return str == null ? runtime.newString() : convertString(runtime, str);
     }
     
-    private static IRubyObject convertJavaStringToRuby(Ruby runtime, String str) {
-        if (runtime.is1_9()) {
-            ByteList bytes = new ByteList(str.getBytes(RubyEncoding.UTF8), UTF8Encoding.INSTANCE);
-            return RubyString.newString(runtime, bytes);
-        } else {
-            return RubyString.newString(runtime, str);
-        }
+    public static RubyString convertString(Ruby runtime, String str) {
+        return RubyString.newUTF8String(runtime, str);
+    }
+
+    public static RubyString convertString(Ruby runtime, CharSequence str) {
+        return RubyString.newUTF8String(runtime, str);
     }
 
     /**
@@ -259,12 +255,7 @@ public class NokogiriHelpers {
         return ("xmlns".equals(localName)) ? null : localName;
     }
 
-    private static Charset utf8 = null;
-    
-    private static Charset getCharsetUTF8() {
-        if (utf8 == null) utf8 = Charset.forName("UTF-8");
-        return utf8;
-    }
+    private static final Charset UTF8 = Charset.forName("UTF-8");
 
     /**
      * Converts a RubyString in to a Java String.  Assumes the
@@ -290,15 +281,7 @@ public class NokogiriHelpers {
     }
     
     private static String toJavaString(RubyString str) {
-        ByteList value = str.getByteList();
-        try {
-            if (str.getRuntime().is1_9()) {
-                return new String(value.getUnsafeBytes(), value.begin(), value.length(), str.getEncoding().toString());
-            }
-            return RubyEncoding.decodeUTF8(value.getUnsafeBytes(), value.begin(), value.length());
-        } catch (UnsupportedEncodingException uee) {
-            return str.toString();
-        }
+        return str.decodeString(); // toString()
     }
 
     public static String rubyStringToString(RubyString str) {
@@ -307,16 +290,15 @@ public class NokogiriHelpers {
         int offset = byteList.begin();
         int len = byteList.length();
         ByteBuffer buf = ByteBuffer.wrap(data, offset, len);
-        return getCharsetUTF8().decode(buf).toString();
+        return UTF8.decode(buf).toString();
     }
-    
-    public static List<String> rubyStringArrayToJavaList(RubyArray ary) {
-        List<String> list = new ArrayList<String>();
-        for (int i=0; i < ary.getLength(); i++) {
-            Object obj = ary.get(i);
-            if (obj != null) list.add(obj.toString());
+
+    public static ByteArrayInputStream stringBytesToStream(final IRubyObject str) {
+        if (str instanceof RubyString || str.respondsTo("to_str")) {
+            final ByteList bytes = str.convertToString().getByteList();
+            return new ByteArrayInputStream(bytes.unsafeBytes(), bytes.begin(), bytes.length());
         }
-        return list;
+        return null;
     }
 
     public static String getNodeCompletePath(Node node) {
@@ -325,19 +307,14 @@ public class NokogiriHelpers {
 
         // TODO: Rename buffer to path.
         String buffer = "";
-        String sep;
-        String name;
-
-        int occur = 0;
-        boolean generic;
 
         cur = node;
 
         do {
-            name = "";
-            sep = "?";
-            occur = 0;
-            generic = false;
+            String name = "";
+            String sep = "?";
+            int occur = 0;
+            boolean generic = false;
 
             if(cur.getNodeType() == Node.DOCUMENT_NODE) {
                 if(buffer.startsWith("/")) break;
@@ -552,16 +529,16 @@ public class NokogiriHelpers {
                 ((a != null) && (b != null) && (b.equals(a))));
     }
 
-    private static Pattern encoded_pattern = Pattern.compile("&amp;|&gt;|&lt;|&#13;");
-    private static Pattern decoded_pattern = Pattern.compile("&|>|<|\r");
-    private static String[] encoded = {"&amp;", "&gt;", "&lt;", "&#13;"};
-    private static String[] decoded = {"&", ">", "<", "\r"};
+    private static final Pattern encoded_pattern = Pattern.compile("&amp;|&gt;|&lt;|&#13;");
+    private static final String[] encoded = {"&amp;", "&gt;", "&lt;", "&#13;"};
+    private static final Pattern decoded_pattern = Pattern.compile("&|>|<|\r");
+    private static final String[] decoded = {"&", ">", "<", "\r"};
 
-    private static String convert(Pattern ptn, String input, String[] oldChars, String[] newChars)  {
+    private static StringBuffer convert(Pattern ptn, CharSequence input, String[] oldChars, String[] newChars)  {
         Matcher matcher = ptn.matcher(input);
         boolean result = matcher.find();
-        StringBuffer sb = new StringBuffer();
-        while(result) {
+        StringBuffer sb = new StringBuffer(input.length() + 8);
+        while (result) {
             String matched = matcher.group();
             String replacement = "";
             for (int i=0; i<oldChars.length; i++) {
@@ -574,15 +551,15 @@ public class NokogiriHelpers {
             result = matcher.find();
         }
         matcher.appendTail(sb);
-        return sb.toString();
+        return sb;
     }
 
-    public static String encodeJavaString(String s) {
-        return convert(decoded_pattern, s, decoded, encoded);
+    public static CharSequence encodeJavaString(CharSequence str) {
+        return convert(decoded_pattern, str, decoded, encoded);
     }
 
-    public static String decodeJavaString(String s) {
-        return convert(encoded_pattern, s, encoded, decoded);
+    public static CharSequence decodeJavaString(CharSequence str) {
+        return convert(encoded_pattern, str, encoded, decoded);
     }
 
     public static String getNodeName(Node node) {
@@ -601,8 +578,7 @@ public class NokogiriHelpers {
 
     public static final String XMLNS_URI = "http://www.w3.org/2000/xmlns/";
     public static boolean isNamespace(Node node) {
-        return (XMLNS_URI.equals(node.getNamespaceURI()) ||
-                isNamespace(node.getNodeName()));
+        return (XMLNS_URI.equals(node.getNamespaceURI()) || isNamespace(node.getNodeName()));
     }
 
     public static boolean isNamespace(String nodeName) {
@@ -618,44 +594,40 @@ public class NokogiriHelpers {
     }
 
     public static boolean isWhitespaceText(ThreadContext context, IRubyObject obj) {
-        if (obj == null || obj.isNil()) return false;
-
-        XmlNode node = (XmlNode) obj;
-        if (!(node instanceof XmlText))
-            return false;
+        //if (obj == null || obj.isNil()) return false;
+        if ( !(obj instanceof XmlText) ) return false;
 
-        String content = rubyStringToString(node.content(context));
-        return content.trim().length() == 0;
+        CharSequence content = ((XmlNode) obj).getContentImpl();
+        return content == null || isWhitespaceText(content);
     }
 
-    public static boolean isWhitespaceText(String s) {
-        return s.trim().length() == 0;
+    public static boolean isWhitespaceText(CharSequence str) {
+        int len = str.length(); int beg = 0;
+        while ((beg < len) && (str.charAt(beg) <= ' ')) beg++;
+        return beg == len;
     }
 
-    public static String canonicalizeWhitespce(String s) {
-        StringBuilder sb = new StringBuilder();
-        char[] chars = s.toCharArray();
+    public static CharSequence canonicalizeWhitespace(CharSequence str) {
+        final int len = str.length();
+        StringBuilder sb = new StringBuilder(len);
         boolean newline_added = false;
-        for (int i=0; i<chars.length; i++) {
-            if (chars[i] == '\n') {
-                if (!newline_added) {
-                    sb.append(chars[i]);
-                    newline_added = true;
+        for ( int i = 0; i < len; i++ ) {
+            char c = str.charAt(i);
+            if ( c == '\n' ) {
+                if ( ! newline_added ) {
+                    sb.append(c); newline_added = true;
                 }
             } else {
-                sb.append(chars[i]);
+                sb.append(c);
             }
         }
-        return sb.toString();
+        return sb;
     }
 
     public static String newQName(String newPrefix, Node node) {
         String tagName = getLocalPart(node.getNodeName());
-        if(newPrefix == null) {
-            return tagName;
-        } else {
-            return newPrefix + ":" + tagName;
-        }
+        if (newPrefix == null) return tagName;
+        return newPrefix + ':' + tagName;
     }
 
     public static RubyArray nodeListToRubyArray(Ruby ruby, NodeList nodes) {
@@ -695,8 +667,7 @@ public class NokogiriHelpers {
     }
 
     private static String guessEncoding() {
-        String name = null;
-        if (name == null) name = System.getProperty("file.encoding");
+        String name = System.getProperty("file.encoding");
         if (name == null) name = "UTF-8";
         return name;
     }
@@ -722,8 +693,8 @@ public class NokogiriHelpers {
 
     private static String resolveSystemId(String baseName, String systemId) {
         if (baseName == null || baseName.length() < 1) return null;
-        String parentName = null;
-        baseName = baseName.replaceAll("%20", " ");
+        String parentName;
+        baseName = baseName.replace("%20", " ");
         File base = new File(baseName);
         if (base.isDirectory()) parentName = baseName;
         else parentName = base.getParent();
@@ -735,53 +706,45 @@ public class NokogiriHelpers {
     }
 
     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;
+        if (encoding == null) return true; // no need to convert encoding
+        return Charset.forName(encoding).compareTo(UTF8) == 0;
     }
 
-    public static byte[] convertEncoding(Charset output_charset, String input_string) throws CharacterCodingException {
-        CharsetEncoder encoder = output_charset.newEncoder();
-        CharBuffer charBuffer = CharBuffer.wrap(input_string);
-        ByteBuffer byteBuffer = encoder.encode(charBuffer);
-        byte[] buffer = new byte[byteBuffer.remaining()];
-        byteBuffer.get(buffer);
-        return buffer;
+    public static ByteBuffer convertEncoding(Charset output_charset, CharSequence input_string) {
+        return output_charset.encode(CharBuffer.wrap(input_string)); // does replace implicitly on un-mappable characters
     }
 
-    public static String convertEncodingByNKFIfNecessary(Ruby runtime, XmlDocument doc, String thing) {
-        if (!(doc instanceof HtmlDocument)) return thing;
+    public static CharSequence convertEncodingByNKFIfNecessary(ThreadContext context, XmlDocument doc, CharSequence str) {
+        if (!(doc instanceof HtmlDocument)) return str;
         String parsed_encoding = ((HtmlDocument)doc).getPraedEncoding();
-        if (parsed_encoding == null) return thing;
+        if (parsed_encoding == null) return str;
         String ruby_encoding = rubyStringToString(doc.getEncoding());
-        if (ruby_encoding == null) return thing;
-        if (Charset.forName(parsed_encoding).compareTo(Charset.forName(ruby_encoding)) == 0) {
-            return thing;
-        } else {
-            return NokogiriHelpers.nkf(runtime, ruby_encoding, thing);
-        }
+        if (ruby_encoding == null) return str;
+        Charset encoding = Charset.forName(ruby_encoding);
+        if (Charset.forName(parsed_encoding).compareTo(encoding) == 0) return str;
+        if (str.length() == 0) return str; // no need to convert
+        return NokogiriHelpers.nkf(context, encoding, str);
     }
 
+    private static final ByteList _Sw = new ByteList(new byte[] { '-','S','w' }, false);
+    private static final ByteList _Jw = new ByteList(new byte[] { '-','J','w' }, false);
+    private static final ByteList _Ew = new ByteList(new byte[] { '-','E','w' }, false);
+    private static final ByteList _Ww = new ByteList(new byte[] { '-','W','w' }, false);
+
     // This method is used from HTML documents. HTML meta tag with encoding specification
     // might appear after non-ascii characters are used. For example, a title tag before
     // a meta tag. In such a case, Xerces encodes characters in UTF-8 without seeing meta tag.
     // Nokogiri uses NKF library to convert characters correct encoding. This means the method
     // works only for JIS/Shift_JIS/EUC-JP.
-    public static String nkf(Ruby runtime, String ruby_encoding, String thing) {
-        StringBuffer sb = new StringBuffer("-");
-        Charset that = Charset.forName(ruby_encoding);
-        if (NokogiriHelpers.shift_jis.compareTo(that) == 0) {
-            sb.append("S");
-        } else if (NokogiriHelpers.jis.compareTo(that) == 0) {
-            sb.append("J");
-        } else if (NokogiriHelpers.euc_jp.compareTo(that) == 0) {
-            sb.append("E");
-        } else {
-            // should not come here. should be treated before this method.
-            sb.append("W");
-        }
-        sb.append("w");
-        Class nkfClass = null;
+    private static CharSequence nkf(ThreadContext context, Charset encoding, CharSequence str) {
+        final Ruby runtime = context.getRuntime();
+        final ByteList opt;
+        if (NokogiriHelpers.shift_jis.compareTo(encoding) == 0) opt = _Sw;
+        else if (NokogiriHelpers.jis.compareTo(encoding) == 0) opt = _Jw;
+        else if (NokogiriHelpers.euc_jp.compareTo(encoding) == 0) opt = _Ew;
+        else opt = _Ww; // should not come here. should be treated before this method.
+
+        Class nkfClass;
         try {
             // JRuby 1.7 and later
             nkfClass = runtime.getClassLoader().loadClass("org.jruby.ext.nkf.RubyNKF");
@@ -790,35 +753,35 @@ public class NokogiriHelpers {
                 // Before JRuby 1.7
                 nkfClass = runtime.getClassLoader().loadClass("org.jruby.RubyNKF");
             } catch (ClassNotFoundException e2) {
-                return thing;
+                return str;
             }
         }
         Method nkf_method;
         try {
             nkf_method = nkfClass.getMethod("nkf", ThreadContext.class, IRubyObject.class, IRubyObject.class, IRubyObject.class);
             RubyString r_str = 
-                (RubyString)nkf_method.invoke(null, runtime.getCurrentContext(), null, runtime.newString(new String(sb)), runtime.newString(thing));
+                (RubyString)nkf_method.invoke(null, context, null, runtime.newString(opt), runtime.newString(str.toString()));
             return NokogiriHelpers.rubyStringToString(r_str);
         } catch (SecurityException e) {
-            return thing;
+            return str;
         } catch (NoSuchMethodException e) {
-            return thing;
+            return str;
         } catch (IllegalArgumentException e) {
-            return thing;
+            return str;
         } catch (IllegalAccessException e) {
-            return thing;
+            return str;
         } catch (InvocationTargetException e) {
-            return thing;
+            return str;
         }
     }
 
-    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");
+    private static final Charset shift_jis = Charset.forName("Shift_JIS");
+    private static final Charset jis = Charset.forName("ISO-2022-JP");
+    private static final Charset euc_jp = Charset.forName("EUC-JP");
 
     public static boolean shouldEncode(Node text) {
-      return text.getUserData(NokogiriHelpers.ENCODED_STRING) == null ||
-          !((Boolean)text.getUserData(NokogiriHelpers.ENCODED_STRING));
+        final Boolean encoded = (Boolean) text.getUserData(NokogiriHelpers.ENCODED_STRING);
+        return encoded == null || ! encoded;
     }
 
     public static boolean shouldDecode(Node text) {