nokogiri 1.5.0-java → 1.5.1-java

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

@@ -1,7 +1,7 @@
 /**
  * (The MIT License)
  *
- * Copyright (c) 2008 - 2011:
+ * Copyright (c) 2008 - 2012:
  *
  * * {Aaron Patterson}[http://tenderlovemaking.com]
  * * {Mike Dalessio}[http://mike.daless.io]
@@ -35,10 +35,17 @@ package nokogiri.internals;
 import java.io.File;
 import java.io.UnsupportedEncodingException;
 import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.charset.CharacterCodingException;
 import java.nio.charset.Charset;
+import java.nio.charset.CharsetDecoder;
+import java.nio.charset.CharsetEncoder;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
+import nokogiri.HtmlDocument;
 import nokogiri.NokogiriService;
 import nokogiri.XmlAttr;
 import nokogiri.XmlCdata;
@@ -57,6 +64,7 @@ import org.jruby.RubyArray;
 import org.jruby.RubyClass;
 import org.jruby.RubyEncoding;
 import org.jruby.RubyString;
+import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.util.ByteList;
 import org.w3c.dom.Attr;
@@ -74,6 +82,7 @@ import org.w3c.dom.NodeList;
 public class NokogiriHelpers {
     public static final String CACHED_NODE = "NOKOGIRI_CACHED_NODE";
     public static final String VALID_ROOT_NODE = "NOKOGIRI_VALIDE_ROOT_NODE";
+    public static final String ENCODED_STRING = "NOKOGIRI_ENCODED_STRING";
 
     public static XmlNode getCachedNode(Node node) {
         return (XmlNode) node.getUserData(CACHED_NODE);
@@ -89,12 +98,14 @@ public class NokogiriHelpers {
         if(node == null) return ruby.getNil();
         if (node.getNodeType() == Node.ATTRIBUTE_NODE && isNamespace(node.getNodeName())) {
             XmlDocument xmlDocument = (XmlDocument)node.getOwnerDocument().getUserData(CACHED_NODE);
+            if (!(xmlDocument instanceof HtmlDocument)) {
             String prefix = getLocalNameForNamespace(((Attr)node).getName());
             prefix = prefix != null ? prefix : "";
             String href = ((Attr)node).getValue();
             XmlNamespace xmlNamespace = xmlDocument.getNamespaceCache().get(prefix, href);
             if (xmlNamespace != null) return xmlNamespace;
             else return XmlNamespace.createFromAttr(ruby, (Attr)node);
+            }
         }
         XmlNode xmlNode = getCachedNode(node);
         if(xmlNode == null) {
@@ -145,7 +156,7 @@ public class NokogiriHelpers {
                 return xmlCdata;
             case Node.DOCUMENT_NODE:
                 XmlDocument xmlDocument = (XmlDocument) NokogiriService.XML_DOCUMENT_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::Document"));
-                xmlDocument.setNode(runtime.getCurrentContext(), node);
+                xmlDocument.setDocumentNode(runtime.getCurrentContext(), node);
                 return xmlDocument;
             case Node.DOCUMENT_TYPE_NODE:
                 XmlDtd xmlDtd = (XmlDtd) NokogiriService.XML_DTD_ALLOCATOR.allocate(runtime, getNokogiriClass(runtime, "Nokogiri::XML::DTD"));
@@ -167,6 +178,11 @@ public class NokogiriHelpers {
         return RubyString.newString(runtime, s);
     }
     
+    public static IRubyObject stringOrNil(Ruby runtime, byte[] bytes) {
+        if (bytes == null) return runtime.getNil();
+        return RubyString.newString(runtime, bytes);
+    }
+    
     public static IRubyObject stringOrBlank(Ruby runtime, String s) {
         if (s == null) return runtime.newString();
         return RubyString.newString(runtime, s);
@@ -263,6 +279,15 @@ public class NokogiriHelpers {
         ByteBuffer buf = ByteBuffer.wrap(data, offset, len);
         return getCharsetUTF8().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());
+        }
+        return list;
+    }
 
     public static String getNodeCompletePath(Node node) {
 
@@ -531,13 +556,6 @@ public class NokogiriHelpers {
         return convert(encoded_pattern, s, encoded, decoded);
     }
 
-    private static Pattern not_escaped_pattern = Pattern.compile("\\&(?!(amp;|gt;|lt;))|<|>");
-    public static boolean isNotXmlEscaped(String s) {
-        if (s == null) return false;
-        Matcher matcher = not_escaped_pattern.matcher(s);
-        return (matcher.find());
-    }
-
     public static String getNodeName(Node node) {
         if(node == null) { System.out.println("node is null"); return ""; }
         String name = node.getNodeName();
@@ -569,6 +587,38 @@ public class NokogiriHelpers {
     public static boolean isXmlBase(String attrName) {
         return "xml:base".equals(attrName) || "xlink:href".equals(attrName);
     }
+    
+    public static boolean isWhitespaceText(ThreadContext context, IRubyObject obj) {
+        if (obj == null || obj.isNil()) return false;
+
+        XmlNode node = (XmlNode) obj;
+        if (!(node instanceof XmlText))
+            return false;
+
+        String content = rubyStringToString(node.content(context));
+        return content.trim().length() == 0;
+    }
+    
+    public static boolean isWhitespaceText(String s) {
+        return s.trim().length() == 0;
+    }
+    
+    public static String canonicalizeWhitespce(String s) {
+        StringBuilder sb = new StringBuilder();
+        char[] chars = s.toCharArray();
+        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;
+                }
+            } else {
+                sb.append(chars[i]);
+            }
+        }
+        return sb.toString();
+    }
 
     public static String newQName(String newPrefix, Node node) {
         if(newPrefix == null) {
@@ -636,4 +686,27 @@ public class NokogiriHelpers {
         if (dtdFile.exists()) return dtdFile.getPath();
         return null;
     }
+    
+    public static boolean isUTF8(String encoding) {
+        if (encoding == null) return true;   // no need to convert encoding
+        int ret = Charset.forName(encoding).compareTo(Charset.forName("UTF-8"));
+        return ret == 0;
+    }
+    
+    public static byte[] convertEncoding(Charset output_charset, String input_string) throws CharacterCodingException {
+        Charset input = Charset.forName("UTF-8");
+        CharsetDecoder decoder = input.newDecoder();
+        CharsetEncoder encoder = output_charset.newEncoder();
+        decoder.reset();
+        encoder.reset();
+        ByteBuffer bbuf = ByteBuffer.wrap(input_string.getBytes());
+        CharBuffer cbuf = decoder.decode(bbuf);
+        bbuf.clear();
+        encoder.encode(cbuf, bbuf, true);
+        int length = bbuf.position();
+        byte[] bytes = new byte[length];
+        System.arraycopy(bbuf.array(), 0, bytes, 0, length);
+        return bytes;
+    }
+    
 }

data/ext/java/nokogiri/internals/NokogiriXsltErrorListener.java

@@ -42,14 +42,15 @@ import javax.xml.transform.TransformerException;
  */
 public class NokogiriXsltErrorListener implements ErrorListener {
     public enum ErrorType {
+        SUCCESS,
         WARNING,
         ERROR,
         FATAL
     }
 
-    private ErrorType type;
-    private String errorMessage;
-    private Exception exception;
+    private ErrorType type = ErrorType.SUCCESS;
+    private String errorMessage = null;
+    private Exception exception = null;
 
     public void warning(TransformerException ex) throws TransformerException {
         type = ErrorType.WARNING;

data/ext/java/nokogiri/internals/ParserContext.java

@@ -1,7 +1,7 @@
 /**
  * (The MIT License)
  *
- * Copyright (c) 2008 - 2011:
+ * Copyright (c) 2008 - 2012:
  *
  * * {Aaron Patterson}[http://tenderlovemaking.com]
  * * {Mike Dalessio}[http://mike.daless.io]
@@ -43,6 +43,7 @@ import java.io.InputStream;
 
 import org.jruby.Ruby;
 import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
 import org.jruby.RubyIO;
 import org.jruby.RubyObject;
 import org.jruby.RubyString;
@@ -65,6 +66,8 @@ import org.xml.sax.ext.EntityResolver2;
  */
 public class ParserContext extends RubyObject {
     protected InputSource source = null;
+    protected IRubyObject detected_encoding = null;
+    protected int stringDataSize = -1;
 
     /**
      * Create a file base input source taking into account the current
@@ -102,11 +105,28 @@ public class ParserContext extends RubyObject {
     public void setInputSource(ThreadContext context, IRubyObject data, IRubyObject url) {
         Ruby ruby = context.getRuntime();
         String path = (String) url.toJava(String.class);
+        if (data.getType().respondsTo("detect_encoding")) {
+            // data is EnocodingReader
+            try {
+                data.callMethod(context, "read", RubyFixnum.newFixnum(context.getRuntime(), 1024));
+            } catch (RaiseException e) {
+                detected_encoding = e.getException().getInstanceVariable("@found_encoding");
+            }
+        }
+
         if (isAbsolutePath(path)) {
-            source = new InputSource();
-            source.setSystemId(path);
+            returnWithSystemId(path);
             return;
         }
+        // Dir.chdir might be called at some point before this.
+        String currentDir = context.getRuntime().getCurrentDirectory();
+        if (path != null && currentDir != null && currentDir.length() != 0) {
+            String absPath = currentDir + "/" + path;
+            if (isAbsolutePath(absPath)) {
+                returnWithSystemId(absPath);
+                return;
+            }
+        }
         RubyString stringData = null;
         if (invoke(context, data, "respond_to?",
                    ruby.newSymbol("to_io").to_sym()).isTrue()) {
@@ -140,6 +160,7 @@ public class ParserContext extends RubyObject {
         }
         if (stringData != null) {
             ByteList bytes = stringData.getByteList();
+            stringDataSize = bytes.length() - bytes.begin();
             source = new InputSource(new ByteArrayInputStream(bytes.unsafeBytes(), bytes.begin(), bytes.length()));
         }
     }
@@ -148,6 +169,15 @@ public class ParserContext extends RubyObject {
         if (url == null) return false;
         return (new File(url)).isAbsolute();
     }
+    
+    private void returnWithSystemId(String url) {
+        source = new InputSource();
+        if (detected_encoding != null) {
+            source.setEncoding((String) detected_encoding.toJava(String.class));
+        }
+        source.setSystemId(url);
+        return;
+    }
 
     /**
      * Set the InputSource to read from <code>file</code>, a String filename.

data/ext/java/nokogiri/internals/SaveContextVisitor.java

@@ -1,7 +1,7 @@
 /**
  * (The MIT License)
  *
- * Copyright (c) 2008 - 2011:
+ * Copyright (c) 2008 - 2012:
  *
  * * {Aaron Patterson}[http://tenderlovemaking.com]
  * * {Mike Dalessio}[http://mike.daless.io]
@@ -32,9 +32,18 @@
 
 package nokogiri.internals;
 
+import static nokogiri.internals.NokogiriHelpers.canonicalizeWhitespce;
 import static nokogiri.internals.NokogiriHelpers.encodeJavaString;
-import static nokogiri.internals.NokogiriHelpers.isNotXmlEscaped;
+import static nokogiri.internals.NokogiriHelpers.isNamespace;
+import static nokogiri.internals.NokogiriHelpers.isWhitespaceText;
 
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.Deque;
+import java.util.Iterator;
+import java.util.List;
 import java.util.Stack;
 
 import org.cyberneko.html.HTMLElements;
@@ -65,7 +74,11 @@ public class SaveContextVisitor {
     private Stack<String> indentation;
     private String encoding, indentString;
     private boolean format, noDecl, noEmpty, noXhtml, asXhtml, asXml, asHtml, asBuilder, htmlDoc, fragment;
-
+    private boolean canonical, incl_ns, with_comments, subsets, exclusive;
+    private List<Node> c14nNodeList;
+    private Deque<Attr[]> c14nNamespaceStack;
+    private Deque<Attr[]> c14nAttrStack;
+    private List<String> c14nExclusiveInclusivePrefixes = null;
     /*
      * U can't touch this.
      * http://www.youtube.com/watch?v=WJ2ZFVx6A4Q
@@ -81,13 +94,22 @@ public class SaveContextVisitor {
     public static final int AS_XML = 32;
     public static final int AS_HTML = 64;
     public static final int AS_BUILDER = 128;
+    
+    public static final int CANONICAL = 1;
+    public static final int INCL_NS = 2;
+    public static final int WITH_COMMENTS = 4;
+    public static final int SUBSETS = 8;
+    public static final int EXCLUSIVE = 16;
 
-    public SaveContextVisitor(int options, String indent, String encoding, boolean htmlDoc, boolean fragment) {
+    public SaveContextVisitor(int options, String indent, String encoding, boolean htmlDoc, boolean fragment, int canonicalOpts) {
         buffer = new StringBuffer();
         this.encoding = encoding;
         indentation = new Stack<String>(); indentation.push("");
         this.htmlDoc = htmlDoc;
         this.fragment = fragment;
+        c14nNodeList = new ArrayList<Node>();
+        c14nNamespaceStack = new ArrayDeque<Attr[]>();
+        c14nAttrStack = new ArrayDeque<Attr[]>();
         format = (options & FORMAT) == FORMAT;
         
         noDecl = (options & NO_DECL) == NO_DECL;
@@ -97,6 +119,12 @@ public class SaveContextVisitor {
         asXml = (options & AS_XML) == AS_XML;
         asHtml = (options & AS_HTML) == AS_HTML;
         asBuilder = (options & AS_BUILDER) == AS_BUILDER;
+        
+        canonical = (canonicalOpts & CANONICAL) == CANONICAL;
+        incl_ns = (canonicalOpts & INCL_NS) == INCL_NS;
+        with_comments = (canonicalOpts & WITH_COMMENTS) == WITH_COMMENTS;
+        subsets = (canonicalOpts & SUBSETS) == SUBSETS;
+        
         if ((format && indent == null) || (format && indent.length() == 0)) indent = "  "; // default, two spaces
         if ((!format && indent != null) && indent.length() > 0) format = true;
         if ((asBuilder && indent == null) || (asBuilder && indent.length() == 0)) indent = "  "; // default, two spaces
@@ -117,6 +145,14 @@ public class SaveContextVisitor {
         this.encoding = encoding;
     }
     
+    public List<Node> getC14nNodeList() {
+        return c14nNodeList;
+    }
+    
+   public void setC14nExclusiveInclusivePrefixes(List<String> prefixes) {
+       c14nExclusiveInclusivePrefixes = prefixes;
+   }
+    
     public boolean enter(Node node) {
         if (node instanceof Document) {
             return enter((Document)node);
@@ -275,6 +311,10 @@ public class SaveContextVisitor {
     }
 
     public boolean enter(Comment comment) {
+        if (canonical) {
+            c14nNodeList.add(comment);
+            if (!with_comments) return true;
+        }
         buffer.append("<!--");
         buffer.append(comment.getData());
         buffer.append("-->");
@@ -293,7 +333,7 @@ public class SaveContextVisitor {
 
             if (encoding != null) {
                 buffer.append(" encoding=\"");
-                buffer.append(encoding.toUpperCase());
+                buffer.append(encoding);
                 buffer.append("\"");
             }
             buffer.append("?>\n");
@@ -306,6 +346,10 @@ public class SaveContextVisitor {
     }
     
     public boolean enter(DocumentType docType) {
+        if (canonical) {
+            c14nNodeList.add(docType);
+            return true;
+        }
         String name = docType.getName();
         String pubId = docType.getPublicId();
         String sysId = docType.getSystemId();
@@ -334,6 +378,12 @@ public class SaveContextVisitor {
     }
 
     public boolean enter(Element element) {
+        if (canonical) {
+            c14nNodeList.add(element);
+            if (element == element.getOwnerDocument().getDocumentElement()) {
+                c14nNodeList.add(element.getOwnerDocument());
+            }
+        }
         String current = indentation.peek();
         buffer.append(current);
         if (needIndent()) {
@@ -341,9 +391,8 @@ public class SaveContextVisitor {
         }
         String name = element.getTagName();
         buffer.append("<" + name);
-        NamedNodeMap attrs = element.getAttributes();
-        for (int i=0; i<attrs.getLength(); i++) {
-            Attr attr = (Attr) attrs.item(i);
+        Attr[] attrs = getAttrsAndNamespaces(element);        
+        for (Attr attr : attrs) {
             if (attr.getSpecified()) {
                 buffer.append(" ");
                 enter(attr);
@@ -356,10 +405,8 @@ public class SaveContextVisitor {
             return true;
         }
         // no child
-        if (asHtml) {
+        if (asHtml || asXhtml) {
             buffer.append(">");   
-        } else if (asXhtml) {
-            buffer.append(" />");
         } else if (asXml && noEmpty) {
             buffer.append(">");
         } else {
@@ -390,7 +437,142 @@ public class SaveContextVisitor {
         return element.isEmpty();
     }
     
+    private Attr[] getAttrsAndNamespaces(Element element) {
+        NamedNodeMap attrs = element.getAttributes();
+        if (!canonical) {
+            if (attrs == null || attrs.getLength() == 0) return new Attr[0];
+            Attr[] attrsAndNamespaces = new Attr[attrs.getLength()];
+            for (int i=0; i<attrs.getLength(); i++) {
+                attrsAndNamespaces[i] = (Attr) attrs.item(i);
+            }
+            return attrsAndNamespaces;
+        } else {
+            List<Attr> namespaces = new ArrayList<Attr>();
+            List<Attr> attributes = new ArrayList<Attr>();
+            if (subsets) {
+                getAttrsOfAncestors(element.getParentNode(), namespaces, attributes);
+                Attr[] namespaceOfAncestors = getSortedArray(namespaces);
+                Attr[] attributeOfAncestors = getSortedArray(attributes);
+                c14nNamespaceStack.push(namespaceOfAncestors);
+                c14nAttrStack.push(attributeOfAncestors);
+                subsets = false; // namespace propagation should be done only once on top level node.
+            }
+            
+            getNamespacesAndAttrs(element, namespaces, attributes);
+
+            Attr[] namespaceArray = getSortedArray(namespaces);
+            Attr[] attributeArray = getSortedArray(attributes);
+            Attr[] allAttrs = new Attr[namespaceArray.length + attributeArray.length];
+            for (int i=0; i<allAttrs.length; i++) {
+                if (i < namespaceArray.length) {
+                    allAttrs[i] = namespaceArray[i];
+                } else {
+                    allAttrs[i] = attributeArray[i-namespaceArray.length];
+                }
+            }
+            c14nNamespaceStack.push(namespaceArray);
+            c14nAttrStack.push(attributeArray);
+            return allAttrs;
+        }
+        
+    }
+    
+    private void getAttrsOfAncestors(Node parent, List<Attr> namespaces, List<Attr> attributes) {
+        if (parent == null) return;
+        NamedNodeMap attrs = parent.getAttributes();
+        if (attrs == null || attrs.getLength() == 0) return;
+        for (int i=0; i < attrs.getLength(); i++) {
+            Attr attr = (Attr)attrs.item(i);
+            if (isNamespace(attr.getNodeName())) namespaces.add(attr);
+            else attributes.add(attr);
+        }
+        getAttrsOfAncestors(parent.getParentNode(), namespaces, attributes);
+    }
+    
+    private void getNamespacesAndAttrs(Node current, List<Attr> namespaces, List<Attr> attributes) {
+        NamedNodeMap attrs = current.getAttributes();
+        for (int i=0; i<attrs.getLength(); i++) {
+            Attr attr = (Attr)attrs.item(i);
+            if (isNamespace(attr.getNodeName())) {
+                getNamespacesWithPropagated(namespaces, attr);
+            } else {
+                getAttributesWithPropagated(attributes, attr);
+            }
+            if (exclusive) {
+                verifyXmlSpace(attributes, attrs);
+            }
+        }
+    }
+
+    private void getNamespacesWithPropagated(List<Attr> namespaces, Attr attr) {
+        boolean newNamespace = true;
+        Iterator<Attr[]> iter = c14nNamespaceStack.iterator();
+        while (iter.hasNext()) {
+            Attr[] parentNamespaces = iter.next();
+            for (int n=0; n < parentNamespaces.length; n++) {
+                if (parentNamespaces[n].getNodeName().equals(attr.getNodeName())) {
+                   if (parentNamespaces[n].getNodeValue().equals(attr.getNodeValue())) {
+                       // exactly the same namespace should not be added
+                       newNamespace = false;
+                   } else {                            
+                       // in case of namespace url change, propagated namespace will be override
+                       namespaces.remove(parentNamespaces[n]);
+                   }
+                }
+            }
+            if (newNamespace && !namespaces.contains(attr)) namespaces.add(attr);
+        }
+    }
+    
+    private void getAttributesWithPropagated(List<Attr> attributes, Attr attr) {
+        boolean newAttribute = true;
+        Iterator<Attr[]> iter = c14nAttrStack.iterator();
+        while (iter.hasNext()) {
+            Attr[] parentAttr = iter.next();
+            for (int n=0; n < parentAttr.length; n++) {
+                if (!parentAttr[n].getNodeName().startsWith("xml:")) continue;
+                if (parentAttr[n].getNodeName().equals(attr.getNodeName())) {
+                   if (parentAttr[n].getNodeValue().equals(attr.getNodeValue())) {
+                       // exactly the same attribute should not be added
+                       newAttribute = false;
+                   } else {                            
+                       // in case of attribute value change, propagated attribute will be override
+                       attributes.remove(parentAttr[n]);
+                   }
+                }
+            }
+            if (newAttribute) attributes.add(attr);
+        }
+    }
+    
+    private void verifyXmlSpace(List<Attr> attributes, NamedNodeMap attrs) {
+        Attr attr = (Attr) attrs.getNamedItem("xml:space");
+        if (attr == null) {
+            for (int i=0; i < attributes.size(); i++) {
+                if (attributes.get(i).getNodeName().equals("xml:space")) {
+                    attributes.remove(i);
+                    break;
+                }
+            }
+        }
+    }
+    
+    private Attr[] getSortedArray(List<Attr> attrList) {
+        Attr[] attrArray = attrList.toArray(new Attr[0]);
+        Arrays.sort(attrArray, new Comparator<Attr>() {
+            @Override
+            public int compare(Attr attr0, Attr attr1) {
+                return attr0.getNodeName().compareTo(attr1.getNodeName());
+            }
+        });
+        return attrArray;
+    }
+    
     public void leave(Element element) {
+        if (canonical) {
+            c14nNamespaceStack.poll();
+            c14nAttrStack.poll();
+        }
         String name = element.getTagName();
         if (element.hasChildNodes()) {
             if (needIndentInClosing(element)) {
@@ -504,6 +686,7 @@ public class SaveContextVisitor {
         if (asHtml) buffer.append(">");
         else buffer.append("?>");
         buffer.append("\n");
+        if (canonical) c14nNodeList.add(pi);
         return true;
     }
     
@@ -514,6 +697,13 @@ public class SaveContextVisitor {
     private static char lineSeparator = '\n'; // System.getProperty("line.separator"); ?
     public boolean enter(Text text) {
         String textContent = text.getNodeValue();
+        if (canonical) {
+            c14nNodeList.add(text);
+            if (isWhitespaceText(textContent)) {
+                buffer.append(canonicalizeWhitespce(textContent));
+                return true;
+            }
+        }
         if (needIndentText() && "".equals(textContent.trim())) return true;
         if (needIndentText()) {
             String current = indentation.peek();
@@ -521,9 +711,10 @@ public class SaveContextVisitor {
             indentation.push(current + indentString);
             if (textContent.charAt(0) == lineSeparator) textContent = textContent.substring(1);    
         }
-        if (isNotXmlEscaped(textContent)) {
+        if (text.getUserData(NokogiriHelpers.ENCODED_STRING) == null || !((Boolean)text.getUserData(NokogiriHelpers.ENCODED_STRING))) {
             textContent = encodeJavaString(textContent);
         }
+
         if (getEncoding(text) == null) {
             textContent = encodeStringToHtmlEntity(textContent);
         }