nokogiri 1.5.5.rc3-java → 1.5.6-java

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

@@ -0,0 +1,109 @@
+package nokogiri.internals;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+import org.jruby.Ruby;
+import org.jruby.RubyObject;
+import org.jruby.RubyProcess.Sys;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.javasupport.util.RuntimeHelpers;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.ByteList;
+
+/**
+ * This class wraps the EncodingReader which act like a rewinding input stream,
+ * it tries to read the first 1K of data to detect the encoding, but save
+ * this data in a buffer for the subsequent read. Unfortunately, the EncodingReader
+ * will behave as expected only if encoding was detected, otherwise, the read data
+ * won't be stored and EncodingReader will fallback to read directory from the io stream.
+ * this is kind of lame, since we need to have similar logic in both layers. The alternative
+ * is to implement the encoding detection similar to the way C-Nokogiri does it; it starts
+ * parsing assuming encoding is unknown and if encoding is detected it will throw an exception
+ * causing parsing to stop, in which case we have to intercept the exception and set the encoding.
+ * Also in this case we don't have to restart the parsing since html/document.rb does that for us.
+ *
+ * @author John Shahid <jvshahid@gmail.com>
+ *
+ */
+public class NokogiriEncodingReaderWrapper extends InputStream {
+  private final ThreadContext context;
+  private final IRubyObject   encodingReader;
+  private final Ruby          ruby;
+  private IRubyObject         detectedEncoding;
+  private final byte[]        firstChunk       = new byte[1024];
+  private int                 firstChunkOff    = 0;
+  private int                 firstChunkLength = 0;
+
+  public NokogiriEncodingReaderWrapper(ThreadContext context, RubyObject encodingReader) {
+    this.context = context;
+    this.encodingReader = encodingReader;
+    this.ruby = context.getRuntime();
+
+    if (!RuntimeHelpers.invoke(context, encodingReader, "respond_to?", ruby.newSymbol("read").to_sym()).isTrue()
+        || encodingReader.getInstanceVariable("@io") == null) {
+      throw ruby.newArgumentError("Argument doesn't respond to read or doesn't have instance variable @io");
+    }
+  }
+
+  public boolean detectEncoding() {
+    try {
+      firstChunkLength = read(firstChunk);
+    } catch (RaiseException e) {
+      detectedEncoding = e.getException().getInstanceVariable("@found_encoding");
+      return true;
+    }
+    detectedEncoding = context.nil;
+    return false;
+  }
+
+  public IRubyObject getEncoding() {
+    return detectedEncoding;
+  }
+
+  @Override
+  public int read(byte b[]) {
+    return read(b, 0, b.length);
+  }
+
+  @Override
+  public int read(byte b[], int off, int len) {
+    if (b == null) {
+      throw new NullPointerException();
+    } else if (off < 0 || len < 0 || len > b.length - off) {
+      throw new IndexOutOfBoundsException();
+    } else if (len == 0) {
+      return 0;
+    }
+
+    int copyLength = Math.min(firstChunkLength - firstChunkOff, len);
+    if (copyLength > 0) {
+      System.arraycopy(firstChunk, firstChunkOff, b, off, copyLength);
+      len -= copyLength;
+      firstChunkOff += copyLength;
+    }
+
+    if (len <= 0)
+      return copyLength;
+
+    IRubyObject returnValue = encodingReader.callMethod(context, "read", ruby.newFixnum(len));
+    if (returnValue.isNil())
+      return -1;
+
+    ByteList bytes = returnValue.asString().getByteList();
+    int length = bytes.length();
+    System.arraycopy(bytes.unsafeBytes(), bytes.getBegin(), b, off + copyLength, length);
+    return length + copyLength;
+  }
+
+  @Override
+  public int read() {
+    byte[] bytes = new byte[1];
+    int count = read(bytes, 0, 1);
+    if (count < 1)
+      return count;
+    return bytes[0];
+  }
+
+}

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

@@ -0,0 +1,123 @@
+package nokogiri.internals;
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+
+import nokogiri.internals.ParserContext.Options;
+
+import org.jruby.Ruby;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+import org.xml.sax.ext.EntityResolver2;
+
+/**
+ * An entity resolver aware of the fact that the Ruby runtime can
+ * change directory but the JVM cannot.  Thus any file based
+ * entity resolution that uses relative paths must be translated
+ * to be relative to the current directory of the Ruby runtime.
+ */
+public class NokogiriEntityResolver implements EntityResolver2 {
+    protected Ruby runtime;
+    private final NokogiriErrorHandler handler;
+    private final Options options;
+
+    public NokogiriEntityResolver(Ruby runtime, NokogiriErrorHandler handler, Options options) {
+        super();
+        this.runtime = runtime;
+        this.handler = handler;
+        this.options = options;
+    }
+
+    @Override
+    public InputSource getExternalSubset(String name, String baseURI)
+        throws SAXException, IOException {
+      return null;
+    }
+
+    @Override
+    public InputSource resolveEntity(String publicId, String systemId)
+        throws SAXException, IOException {
+        return resolveEntity(runtime, null, publicId, null, systemId);
+    }
+
+    @Override
+    public InputSource resolveEntity(String name,
+                                     String publicId,
+                                     String baseURI,
+                                     String systemId)
+        throws SAXException, IOException {
+        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 InputSource emptyInputSource(InputSource source) {
+      source.setByteStream(new ByteArrayInputStream(new byte[0]));
+      return source;
+    }
+
+    private boolean shouldLoadDtd() {
+      return options.dtdLoad || options.dtdValid;
+    }
+
+    private void addError(String errorMessage) {
+      if (handler != null)
+        handler.errors.add(new Exception(errorMessage));
+    }
+
+    /**
+     * Create a file base input source taking into account the current
+     * directory of <code>runtime</code>.
+     * @throws SAXException
+     */
+    protected InputSource resolveEntity(Ruby runtime, String name, String publicId, String baseURI, String systemId)
+        throws IOException, SAXException {
+        InputSource s = new InputSource();
+        if (name.equals("[dtd]") && !shouldLoadDtd()) {
+          return emptyInputSource(s);
+        } else if (!name.equals("[dtd]") && !options.noEnt) {
+          return emptyInputSource(s);
+        }
+        String adjustedSystemId;
+        URI uri = URI.create(systemId);
+        if (options.noNet && uri.getHost() != null) {
+          addError("Attempt to load network entity " + systemId);
+          return emptyInputSource(s);
+        }
+        // if this is a url or absolute file name then use it
+        if (uri.isAbsolute() && !uri.isOpaque()) {
+          adjustedSystemId = uri.toURL().toString();
+        } else if (new File(uri.getPath()).isAbsolute()) {
+          adjustedSystemId = uri.getPath();
+        } else if (baseURI != null) {
+          URI baseuri = URI.create(baseURI);
+          if (options.noNet && baseuri.getHost() != null) {
+            addError("Attempt to load network entity " + systemId);
+            return emptyInputSource(s);
+          }
+          if (baseuri.getHost() == null) {
+            // this is a local file
+            adjustedSystemId = join(baseuri.getPath(), uri.getPath()).getCanonicalPath();
+          } else {
+            // this is a url, then resolve uri using baseuri
+            adjustedSystemId = baseuri.resolve(systemId).toURL().toString();
+          }
+        } else {
+          // baseURI is null we have to use the current working directory to resolve the entity
+          String pwd = runtime.getCurrentDirectory();
+          adjustedSystemId = join(pwd, uri.getPath()).getCanonicalPath();
+        }
+        s.setSystemId(adjustedSystemId);
+        s.setPublicId(publicId);
+        return s;
+    }
+
+}

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

@@ -62,12 +62,10 @@ import org.xml.sax.ext.DefaultHandler2;
  * @author Yoko Harada <yokolet@gmail.com>
  */
 public class NokogiriHandler extends DefaultHandler2 implements XmlDeclHandler {
-
-    boolean inCDATA = false;
-
-    private Ruby ruby;
-    private RubyClass attrClass;
-    private IRubyObject object;
+    private StringBuffer buffer;
+    private final Ruby ruby;
+    private final RubyClass attrClass;
+    private final IRubyObject object;
 
     /**
      * Stores parse errors with the most-recent error last.
@@ -75,11 +73,11 @@ public class NokogiriHandler extends DefaultHandler2 implements XmlDeclHandler {
      * TODO: should these be stored in the document 'errors' array?
      * Currently only string messages are stored there.
      */
-    private LinkedList<XmlSyntaxError> errors = new LinkedList<XmlSyntaxError>();
-    
+    private final LinkedList<XmlSyntaxError> errors = new LinkedList<XmlSyntaxError>();
+
     private Locator locator;
-    private ArrayDeque<Integer> lines;
-    private ArrayDeque<Integer> columns;
+    private final ArrayDeque<Integer> lines;
+    private final ArrayDeque<Integer> columns;
     private static String htmlParserName = "Nokogiri::HTML::SAX::Parser";
     private boolean needEmptyAttrCheck = false;
 
@@ -108,6 +106,7 @@ public class NokogiriHandler extends DefaultHandler2 implements XmlDeclHandler {
         call("start_document");
     }
 
+    @Override
     public void xmlDecl(String version, String encoding, String standalone) {
         call("xmldecl", stringOrNil(ruby, version),
              stringOrNil(ruby, encoding),
@@ -119,6 +118,11 @@ public class NokogiriHandler extends DefaultHandler2 implements XmlDeclHandler {
         call("end_document");
     }
 
+    @Override
+    public void processingInstruction(String target, String data) {
+      call("processing_instruction", ruby.newString(target), ruby.newString(data));
+    }
+
     /*
      * This has to call either "start_element" or
      * "start_element_namespace" depending on whether there are any
@@ -235,8 +239,11 @@ public class NokogiriHandler extends DefaultHandler2 implements XmlDeclHandler {
 
     @Override
     public void characters(char[] ch, int start, int length) throws SAXException {
-        String target = inCDATA ? "cdata_block" : "characters";
-        call(target, ruby.newString(new String(ch, start, length)));
+        if (buffer != null) {
+          buffer.append(new String(ch, start, length));
+        } else {
+          call("characters", ruby.newString(new String(ch, start, length)));
+        }
     }
 
     @Override
@@ -246,12 +253,13 @@ public class NokogiriHandler extends DefaultHandler2 implements XmlDeclHandler {
 
     @Override
     public void startCDATA() throws SAXException {
-        inCDATA = true;
+        buffer = new StringBuffer();
     }
 
     @Override
     public void endCDATA() throws SAXException {
-        inCDATA = false;
+        call("cdata_block", ruby.newString(buffer.toString()));
+        buffer = null;
     }
 
     @Override

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

@@ -45,7 +45,6 @@ import java.nio.charset.CharsetEncoder;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Set;
-import java.util.SortedMap;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
@@ -63,6 +62,7 @@ import nokogiri.XmlNode;
 import nokogiri.XmlProcessingInstruction;
 import nokogiri.XmlText;
 
+import org.jcodings.specific.UTF8Encoding;
 import org.jruby.Ruby;
 import org.jruby.RubyArray;
 import org.jruby.RubyClass;
@@ -179,7 +179,7 @@ public class NokogiriHelpers {
 
     public static IRubyObject stringOrNil(Ruby runtime, String s) {
         if (s == null) return runtime.getNil();
-        return RubyString.newString(runtime, s);
+        return convertJavaStringToRuby(runtime, s);
     }
     
     public static IRubyObject stringOrNil(Ruby runtime, byte[] bytes) {
@@ -189,7 +189,16 @@ public class NokogiriHelpers {
     
     public static IRubyObject stringOrBlank(Ruby runtime, String s) {
         if (s == null) return runtime.newString();
-        return RubyString.newString(runtime, s);
+        return convertJavaStringToRuby(runtime, s);
+    }
+    
+    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);
+        }
     }
 
     /**
@@ -582,7 +591,7 @@ public class NokogiriHelpers {
     }
 
     public static boolean isNamespace(String nodeName) {
-        return (nodeName.equals("xmlns") || nodeName.startsWith("xmlns:"));
+        return (nodeName.startsWith("xmlns"));
     }
 
     public static boolean isNonDefaultNamespace(Node node) {
@@ -675,9 +684,9 @@ public class NokogiriHelpers {
         if (name == null) name = "UTF-8";
         return name;
     }
-    
-    private static Set<String> charsetNames = ((SortedMap<String, Charset>)Charset.availableCharsets()).keySet();
-    
+
+    private static Set<String> charsetNames = Charset.availableCharsets().keySet();
+
     private static String ignoreInvalidEncoding(Ruby runtime, IRubyObject encoding) {
         String givenEncoding = rubyStringToString(encoding);
         if (charsetNames.contains(givenEncoding)) return givenEncoding;
@@ -797,4 +806,13 @@ public class NokogiriHelpers {
     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");
+
+    public static boolean shouldEncode(Node text) {
+      return text.getUserData(NokogiriHelpers.ENCODED_STRING) == null ||
+          !((Boolean)text.getUserData(NokogiriHelpers.ENCODED_STRING));
+    }
+
+    public static boolean shouldDecode(Node text) {
+      return !shouldEncode(text);
+    }
 }

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

@@ -108,7 +108,8 @@ public class ParserContext extends RubyObject {
                 (RubyIO) TypeConverter.convertToType(data,
                                                      ruby.getIO(),
                                                      "to_io");
-            source.setByteStream(io.getInStream());
+            // use unclosedable input stream to fix #495
+            source.setByteStream(new UncloseableInputStream(io.getInStream()));
         } else {
             if (invoke(context, data, "respond_to?",
                           ruby.newSymbol("string").to_sym()).isTrue()) {

data/ext/java/nokogiri/internals/ReaderNode.java

@@ -117,7 +117,8 @@ public abstract class ReaderNode {
         RubyArray array = RubyArray.newArray(ruby);
         if (attributeList != null && attributeList.length > 0) {
             if (document == null) {
-                document = ((XmlDocument) NokogiriService.XML_DOCUMENT_ALLOCATOR.allocate(ruby, getNokogiriClass(ruby, "Nokogiri::XML::Document"))).getDocument();
+                XmlDocument doc = (XmlDocument) XmlDocument.rbNew(ruby.getCurrentContext(), getNokogiriClass(ruby, "Nokogiri::XML::Document"), new IRubyObject[0]);
+                document = doc.getDocument();
             }
             for (int i=0; i<attributeList.length; i++) {
                 if (!isNamespace(attributeList.names.get(i))) {

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

@@ -17,10 +17,10 @@
  * distribute, sublicense, and/or sell copies of the Software, and to
  * permit persons to whom the Software is furnished to do so, subject to
  * the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be
  * included in all copies or substantial portions of the Software.
- * 
+ *
  * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
@@ -65,21 +65,33 @@ import org.w3c.dom.Text;
 
 /**
  * A class for serializing a document.
- * 
+ *
  * @author sergio
  * @author Patrick Mahoney <pat@polycrystal.org>
  * @author Yoko Harada <yokolet@gmail.com>
  */
 public class SaveContextVisitor {
 
-    private StringBuffer buffer;
-    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 final StringBuffer buffer;
+    private final Stack<String> indentation;
+    private String encoding;
+    private final String indentString;
+    private boolean format;
+    private final boolean noDecl;
+    private final boolean noEmpty;
+    private final boolean noXhtml;
+    private final boolean asXhtml;
+    private boolean asXml;
+    private final boolean asHtml;
+    private final boolean asBuilder;
+    private boolean htmlDoc;
+    private final boolean fragment;
+    private final boolean canonical, incl_ns, with_comments;
+    private boolean subsets;
+    private boolean exclusive;
+    private final List<Node> c14nNodeList;
+    private final Deque<Attr[]> c14nNamespaceStack;
+    private final Deque<Attr[]> c14nAttrStack;
     private List<String> c14nExclusiveInclusivePrefixes = null;
     /*
      * U can't touch this.
@@ -96,7 +108,7 @@ 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;
@@ -113,7 +125,7 @@ public class SaveContextVisitor {
         c14nNamespaceStack = new ArrayDeque<Attr[]>();
         c14nAttrStack = new ArrayDeque<Attr[]>();
         format = (options & FORMAT) == FORMAT;
-        
+
         noDecl = (options & NO_DECL) == NO_DECL;
         noEmpty = (options & NO_EMPTY) == NO_EMPTY;
         noXhtml = (options & NO_XHTML) == NO_XHTML;
@@ -121,40 +133,40 @@ 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
         indentString = indent;
         if (!asXml && !asHtml && !asXhtml && !asBuilder) asXml = true;
     }
-    
+
     @Override
     public String toString() {
         return (new String(buffer));
     }
-    
+
     public void setHtmlDoc(boolean htmlDoc) {
         this.htmlDoc = htmlDoc;
     }
-    
+
     public void setEncoding(String encoding) {
         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);
@@ -181,7 +193,7 @@ public class SaveContextVisitor {
             return enter((Entity)node);
         }
         if (node instanceof EntityReference) {
-            return enter((EntityReference)node);
+            return enter(node);
         }
         if (node instanceof Notation) {
             return enter((Notation)node);
@@ -191,7 +203,7 @@ public class SaveContextVisitor {
         }
         return false;
     }
-    
+
     public void leave(Node node) {
         if (node instanceof Document) {
             leave((Document)node);
@@ -206,7 +218,6 @@ public class SaveContextVisitor {
             return;
         }
         if (node instanceof Text) {
-            leave((Text)node);
             return;
         }
         if (node instanceof CDATASection) {
@@ -226,7 +237,7 @@ public class SaveContextVisitor {
             return;
         }
         if (node instanceof EntityReference) {
-            leave((EntityReference)node);
+            leave(node);
             return;
         }
         if (node instanceof Notation) {
@@ -238,16 +249,16 @@ public class SaveContextVisitor {
             return;
         }
     }
-    
+
     public boolean enter(String string) {
         buffer.append(string);
         return true;
     }
-    
+
     public void leave(String string) {
         // no-op
     }
-    
+
     public boolean enter(Attr attr) {
         String name = attr.getName();
         buffer.append(name);
@@ -260,34 +271,34 @@ public class SaveContextVisitor {
         }
         return true;
     }
-    
-    private static Pattern p = 
+
+    private static Pattern p =
         Pattern.compile("charset(()|\\s+)=(()|\\s+)(\\w|\\_|\\.|\\-)+", Pattern.CASE_INSENSITIVE);
-    
+
     private String replaceCharsetIfNecessary(Attr attr) {
         String value = attr.getValue();
         if (encoding == null) return value;   // unable to replace in any case
         if (!"content".equals(attr.getName().toLowerCase())) return value;  // must be content attr
-        if (!"meta".equals(attr.getOwnerElement().getNodeName().toLowerCase())) return value;        
+        if (!"meta".equals(attr.getOwnerElement().getNodeName().toLowerCase())) return value;
         Matcher m = p.matcher(value);
         if (!m.find()) return value;
         if (value.contains(encoding)) return value;  // no need to replace
         return value.replace(m.group(), "charset=" + encoding);
     }
-    
+
     public static final String[] HTML_BOOLEAN_ATTRS = {
         "checked", "compact", "declare", "defer", "disabled", "ismap",
         "multiple", "nohref", "noresize", "noshade", "nowrap", "readonly",
         "selected"
     };
-    
+
     private boolean isHtmlBooleanAttr(String name) {
         for (String s : HTML_BOOLEAN_ATTRS) {
             if (s.equals(name)) return true;
         }
         return false;
     }
-    
+
     private String serializeAttrTextContent(String s, boolean htmlDoc) {
         if (s == null) return "";
 
@@ -299,7 +310,7 @@ public class SaveContextVisitor {
             case '\n': buffer.append("&#10;"); break;
             case '\r': buffer.append("&#13;"); break;
             case '\t': buffer.append("&#9;"); break;
-            case '"': if (htmlDoc) buffer.append("%22"); 
+            case '"': if (htmlDoc) buffer.append("%22");
                 else buffer.append("&quot;");
                 break;
             case '<': buffer.append("&lt;"); break;
@@ -315,14 +326,14 @@ public class SaveContextVisitor {
     public void leave(Attr attr) {
         // no-op
     }
-    
+
     public boolean enter(CDATASection cdata) {
         buffer.append("<![CDATA[");
         buffer.append(cdata.getData());
         buffer.append("]]>");
         return true;
     }
-    
+
     public void leave(CDATASection cdata) {
         // no-op
     }
@@ -337,11 +348,11 @@ public class SaveContextVisitor {
         buffer.append("-->");
         return true;
     }
-    
+
     public void leave(Comment comment) {
         // no-op
     }
-    
+
     public boolean enter(Document document) {
         if (!noDecl) {
             buffer.append("<?xml version=\"");
@@ -357,11 +368,11 @@ public class SaveContextVisitor {
         }
         return true;
     }
-    
+
     public void leave(Document document) {
         // no-op
     }
-    
+
     public boolean enter(DocumentType docType) {
         if (canonical) {
             c14nNodeList.add(docType);
@@ -389,7 +400,7 @@ public class SaveContextVisitor {
         buffer.append(">\n");
         return true;
     }
-    
+
     public void leave(DocumentType docType) {
         // no-op
     }
@@ -403,12 +414,12 @@ public class SaveContextVisitor {
         }
         String current = indentation.peek();
         buffer.append(current);
-        if (needIndent()) {
+        if (needIndent(element)) {
             indentation.push(current + indentString);
         }
         String name = element.getTagName();
         buffer.append("<" + name);
-        Attr[] attrs = getAttrsAndNamespaces(element);        
+        Attr[] attrs = getAttrsAndNamespaces(element);
         for (Attr attr : attrs) {
             if (attr.getSpecified()) {
                 buffer.append(" ");
@@ -423,7 +434,7 @@ public class SaveContextVisitor {
         }
         // no child
         if (asHtml || asXhtml) {
-            buffer.append(">");   
+            buffer.append(">");
         } else if (asXml && noEmpty) {
             buffer.append(">");
         } else {
@@ -434,26 +445,28 @@ public class SaveContextVisitor {
         }
         return true;
     }
-    
-    private boolean needIndent() {
+
+    private boolean needIndent(Element element) {
+        if (containsText(element)) return false;
         if (fragment) return false;  // a given option might be fragment and format. fragment matters
         if (format || asBuilder) return true;
         return false;
     }
-    
+
     private boolean needBreakInOpening(Element element) {
+        if (containsText(element)) return false;
         if (fragment) return false;
         if (format) return true;
         if (asBuilder && element.getFirstChild() != null && element.getFirstChild().getNodeType() == Node.ELEMENT_NODE) return true;
         if (format && element.getNextSibling() == null && element.hasChildNodes()) return true;
         return false;
     }
-    
+
     private boolean isEmpty(String name) {
         HTMLElements.Element element = HTMLElements.getElement(name);
         return element.isEmpty();
     }
-    
+
     private Attr[] getAttrsAndNamespaces(Element element) {
         NamedNodeMap attrs = element.getAttributes();
         if (!canonical) {
@@ -474,7 +487,7 @@ public class SaveContextVisitor {
                 c14nAttrStack.push(attributeOfAncestors);
                 subsets = false; // namespace propagation should be done only once on top level node.
             }
-            
+
             getNamespacesAndAttrs(element, namespaces, attributes);
 
             Attr[] namespaceArray = getSortedArray(namespaces);
@@ -491,9 +504,9 @@ public class SaveContextVisitor {
             c14nAttrStack.push(attributeArray);
             return allAttrs;
         }
-        
+
     }
-    
+
     private void getAttrsOfAncestors(Node parent, List<Attr> namespaces, List<Attr> attributes) {
         if (parent == null) return;
         NamedNodeMap attrs = parent.getAttributes();
@@ -505,7 +518,7 @@ public class SaveContextVisitor {
         }
         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++) {
@@ -531,7 +544,7 @@ public class SaveContextVisitor {
                    if (parentNamespaces[n].getNodeValue().equals(attr.getNodeValue())) {
                        // exactly the same namespace should not be added
                        newNamespace = false;
-                   } else {                            
+                   } else {
                        // in case of namespace url change, propagated namespace will be override
                        namespaces.remove(parentNamespaces[n]);
                    }
@@ -540,7 +553,7 @@ public class SaveContextVisitor {
             if (newNamespace && !namespaces.contains(attr)) namespaces.add(attr);
         }
     }
-    
+
     private void getAttributesWithPropagated(List<Attr> attributes, Attr attr) {
         boolean newAttribute = true;
         Iterator<Attr[]> iter = c14nAttrStack.iterator();
@@ -552,7 +565,7 @@ public class SaveContextVisitor {
                    if (parentAttr[n].getNodeValue().equals(attr.getNodeValue())) {
                        // exactly the same attribute should not be added
                        newAttribute = false;
-                   } else {                            
+                   } else {
                        // in case of attribute value change, propagated attribute will be override
                        attributes.remove(parentAttr[n]);
                    }
@@ -561,7 +574,7 @@ public class SaveContextVisitor {
             if (newAttribute) attributes.add(attr);
         }
     }
-    
+
     private void verifyXmlSpace(List<Attr> attributes, NamedNodeMap attrs) {
         Attr attr = (Attr) attrs.getNamedItem("xml:space");
         if (attr == null) {
@@ -573,7 +586,7 @@ public class SaveContextVisitor {
             }
         }
     }
-    
+
     private Attr[] getSortedArray(List<Attr> attrList) {
         Attr[] attrArray = attrList.toArray(new Attr[0]);
         Arrays.sort(attrArray, new Comparator<Attr>() {
@@ -584,7 +597,7 @@ public class SaveContextVisitor {
         });
         return attrArray;
     }
-    
+
     public void leave(Element element) {
         if (canonical) {
             c14nNamespaceStack.poll();
@@ -596,10 +609,10 @@ public class SaveContextVisitor {
                 indentation.pop();
                 buffer.append(indentation.peek());
             } else if (asBuilder) {
-                indentation.pop();
+                if (!containsText(element)) indentation.pop();
             }
             buffer.append("</" + name + ">");
-            if (needBreakInClosing()) {
+            if (needBreakInClosing(element)) {
                 buffer.append("\n");
             }
             return;
@@ -610,25 +623,31 @@ public class SaveContextVisitor {
                 buffer.append("</" + name + ">");
             }
         }
-        if (needBreakInClosing()) {
-            indentation.pop();
+        if (needBreakInClosing(element)) {
+            if (!containsText(element)) indentation.pop();
             buffer.append("\n");
         }
     }
-    
+
     private boolean needIndentInClosing(Element element) {
+        if (containsText(element)) return false;
+
         if (fragment) return false;  // a given option might be fragment and format. fragment matters
         if (format) return true;
         if (asBuilder && element.getFirstChild() != null && element.getFirstChild().getNodeType() == Node.ELEMENT_NODE) return true;
         return false;
     }
-    
-    private boolean needBreakInClosing() {
+
+    private boolean needBreakInClosing(Element element) {
         if (fragment) return false;
         if (format || asBuilder) return true;
         return false;
     }
 
+    private boolean containsText(Element element) {
+        return (element.getFirstChild() != null && element.getFirstChild().getNodeType() == Node.TEXT_NODE);
+    }
+
     public boolean enter(Entity entity) {
         String name = entity.getNodeName();
         String pubId = entity.getPublicId();
@@ -653,20 +672,21 @@ public class SaveContextVisitor {
         buffer.append(">");
         return true;
     }
-    
+
     public void leave(Entity entity) {
         // no-op
     }
 
-    public boolean enter(EntityReference entityRef) {
-        // no-op?
+    public boolean enterEntityReference(Text entityRef) {
+        String name = entityRef.getNodeName();
+        buffer.append("&" + name + ";");
         return true;
     }
-    
-    public void leave(EntityReference entityRef) {
+
+    public void leaveEntityReference(Text entityRef) {
         // no-op
     }
-    
+
     public boolean enter(Notation notation) {
         String name = notation.getNodeName();
         String pubId = notation.getPublicId();
@@ -690,7 +710,7 @@ public class SaveContextVisitor {
         buffer.append(">");
         return true;
     }
-    
+
     public void leave(Notation notation) {
         // no-op
     }
@@ -706,7 +726,7 @@ public class SaveContextVisitor {
         if (canonical) c14nNodeList.add(pi);
         return true;
     }
-    
+
     public void leave(ProcessingInstruction pi) {
         // no-op
     }
@@ -721,14 +741,8 @@ public class SaveContextVisitor {
                 return true;
             }
         }
-        if (needIndentText() && "".equals(textContent.trim())) return true;
-        if (needIndentText()) {
-            String current = indentation.peek();
-            buffer.append(current);
-            indentation.push(current + indentString);
-            if (textContent.charAt(0) == lineSeparator) textContent = textContent.substring(1);    
-        }
-        if (text.getUserData(NokogiriHelpers.ENCODED_STRING) == null || !((Boolean)text.getUserData(NokogiriHelpers.ENCODED_STRING))) {
+
+        if (NokogiriHelpers.shouldEncode(text)) {
             textContent = encodeJavaString(textContent);
         }
 
@@ -738,29 +752,13 @@ public class SaveContextVisitor {
         buffer.append(textContent);
         return true;
     }
-    
-    private boolean needIndentText() {
-        if (fragment) return false;
-        if (format) return true;
-        return false;
-    }
-    
-    public void leave(Text text) {
-        String textContent = text.getNodeValue();
-        if (needIndentText() && !"".equals(textContent.trim())) {
-            indentation.pop();
-            if (textContent.charAt(textContent.length()-1) != lineSeparator) {
-                buffer.append("\n");
-            }
-        }
-    }
-    
+
     private String getEncoding(Text text) {
         if (encoding != null) return encoding;
         encoding = text.getOwnerDocument().getInputEncoding();
         return encoding;
     }
-    
+
     private String encodeStringToHtmlEntity(String text) {
         int last = 126; // = U+007E. No need to encode under U+007E.
         StringBuffer sb = new StringBuffer();