diff --git a/build.xml b/build.xml
new file mode 100644
index 0000000..7561561
--- /dev/null
+++ b/build.xml
@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<project name="java-diff-utils" default="jar" basedir=".">
+    <property name="version" value="1.2"/>
+    <property name="src.dir" value="./src" />
+    <property name="build.dir" location="./build" />
+    <property name="dist.dir" value="./dist" />
+    <property name="jar.file.name" value="${dist.dir}/${ant.project.name}-${version}.jar" />
+    <property name="src.zip.file.name" value="${dist.dir}/${ant.project.name}-${version}src.zip" />
+    <property name="compiler.jdk.version" value="1.5" />
+
+    <target name="clean-compile">
+        <delete dir="${build.dir}" />
+        <mkdir dir="${build.dir}" />
+    </target>
+    
+    <target name="clean-all" depends="clean-compile">
+        <delete dir="${dist.dir}" />
+    </target>
+
+    <target name="compile" depends="clean-compile">
+        <echo
+            message="Building with Java version: ${java.version} for JDK version: ${compiler.jdk.version}" />
+        <javac source="${compiler.jdk.version}" target="${compiler.jdk.version}"
+            deprecation="off" fork="true" memoryinitialsize="128m"
+            memorymaximumsize="256m" optimize="on" debug="on" depend="false"
+            srcdir="${src.dir}" destdir="${build.dir}">
+        </javac>
+    </target>
+
+    <target name="jar" depends="compile">
+        <mkdir dir="${dist.dir}" />
+        <jar destfile="${jar.file.name}" basedir="${build.dir}" includes="**/*.class" />
+    </target>
+    
+    <target name="source">
+        <mkdir dir="${dist.dir}" />
+        <zip destfile="${src.zip.file.name}" basedir="${src.dir}" />
+    </target>
+    
+    <target name="all" depends="jar, source" />
+
+</project>
\ No newline at end of file
diff --git a/src/difflib/ChangeDelta.java b/src/difflib/ChangeDelta.java
index 828e43f..5d85eda 100644
--- a/src/difflib/ChangeDelta.java
+++ b/src/difflib/ChangeDelta.java
@@ -15,7 +15,7 @@
 
     You should have received a copy of the GNU General Public License
     along with Java Diff Utills Library.  If not, see <http://www.gnu.org/licenses/>.
-*/
+ */
 package difflib;
 
 import java.util.List;
@@ -26,59 +26,60 @@
  * @author <a href="dm.naumenko@gmail.com">Dmitry Naumenko</a>
  */
 public class ChangeDelta extends Delta {
-
-	/**
-	 * {@inheritDoc}
-	 */
-	public ChangeDelta(Chunk original, Chunk revised) {
-		super(original, revised);
-	}
-
-	/**
-	 * {@inheritDoc}
-	 * @throws PatchFailedException 
-	 */
-	@Override
-	public void applyTo(List<Object> target) throws PatchFailedException {
-		verify(target);
-		int position = getOriginal().getPosition();
-		int size = getOriginal().getSize();
-		for (int i = 0; i < size; i++) {
-			target.remove(position);
-		}
-		int i = 0;
-		for (Object line: getRevised().getLines()) {
-			target.add(position + i, line);
-			i++;
-		}
-	}
-
-	/**
-	 * {@inheritDoc}
-	 */
-	@Override
-	public void restore(List<Object> target) {
-		int position = getRevised().getPosition();
-		int size = getRevised().getSize();
-		for (int i = 0; i < size; i++) {
-			target.remove(position);
-		}
-		int i = 0;
-		for (Object line: getOriginal().getLines()) {
-			target.add(position + i, line);
-			i++;
-		}
-	}
-
-	/**
-	 * {@inheritDoc}
-	 */
-	public void verify(List<?> target) throws PatchFailedException {
-		getOriginal().verify(target);
+    
+    /**
+     * {@inheritDoc}
+     */
+    public ChangeDelta(Chunk original, Chunk revised) {
+        super(original, revised);
+    }
+    
+    /**
+     * {@inheritDoc}
+     * 
+     * @throws PatchFailedException
+     */
+    @Override
+    public void applyTo(List<Object> target) throws PatchFailedException {
+        verify(target);
+        int position = getOriginal().getPosition();
+        int size = getOriginal().getSize();
+        for (int i = 0; i < size; i++) {
+            target.remove(position);
+        }
+        int i = 0;
+        for (Object line : getRevised().getLines()) {
+            target.add(position + i, line);
+            i++;
+        }
+    }
+    
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void restore(List<Object> target) {
+        int position = getRevised().getPosition();
+        int size = getRevised().getSize();
+        for (int i = 0; i < size; i++) {
+            target.remove(position);
+        }
+        int i = 0;
+        for (Object line : getOriginal().getLines()) {
+            target.add(position + i, line);
+            i++;
+        }
+    }
+    
+    /**
+     * {@inheritDoc}
+     */
+    public void verify(List<?> target) throws PatchFailedException {
+        getOriginal().verify(target);
         if (getOriginal().getPosition() > target.size()) {
-            throw new PatchFailedException("Incorrect patch for delta: " +
-            		"delta original position > target size");
+            throw new PatchFailedException("Incorrect patch for delta: "
+                    + "delta original position > target size");
         }
-	}
-
+    }
+    
 }
diff --git a/src/difflib/Chunk.java b/src/difflib/Chunk.java
index 3a389de..bc64e6b 100644
--- a/src/difflib/Chunk.java
+++ b/src/difflib/Chunk.java
@@ -15,7 +15,7 @@
 
     You should have received a copy of the GNU General Public License
     along with Java Diff Utills Library.  If not, see <http://www.gnu.org/licenses/>.
-*/
+ */
 package difflib;
 
 import java.util.*;
@@ -23,149 +23,168 @@
 /**
  * Holds the information about the part of text involved in the diff process
  * 
- * <p>Text is represented as <code>Object[]</code> because
- * the diff engine is capable of handling more than plain ascci. In fact,
- * arrays or lists of any type that implements
- * {@link java.lang.Object#hashCode hashCode()} and
- * {@link java.lang.Object#equals equals()}
- * correctly can be subject to differencing using this
- * library.</p>
+ * <p>
+ * Text is represented as <code>Object[]</code> because the diff engine is
+ * capable of handling more than plain ascci. In fact, arrays or lists of any
+ * type that implements {@link java.lang.Object#hashCode hashCode()} and
+ * {@link java.lang.Object#equals equals()} correctly can be subject to
+ * differencing using this library.
+ * </p>
  * 
  * @author <a href="dm.naumenko@gmail.com>Dmitry Naumenko</a>
  */
 public class Chunk {
-	private int position;
-	private int size;
-	private List<?> lines;
-	
-	/**
-	 * Creates a chunk and saves a copy of affected lines
-	 * 
-	 * @param position the start position
-	 * @param size the size of a Chunk
-	 * @param lines the affected lines  
-	 */
-	public Chunk(int position, int size, List<?> lines) {
-		this.position = position;
-		this.size = size;
-		this.lines = lines;
-	}
-	
-	/**
-	 * Creates a chunk and saves a copy of affected lines
-	 * 
-	 * @param position the start position
-	 * @param size the size of a Chunk
-	 * @param lines the affected lines  
-	 */
-	public Chunk(int position, int size, Object[] lines) {
-		this.position = position;
-		this.size = size;
-		this.lines = Arrays.asList(lines);
-	}
-	
+    private int position;
+    private int size;
+    private List<?> lines;
+    
+    /**
+     * Creates a chunk and saves a copy of affected lines
+     * 
+     * @param position
+     *            the start position
+     * @param size
+     *            the size of a Chunk
+     * @param lines
+     *            the affected lines
+     */
+    public Chunk(int position, int size, List<?> lines) {
+        this.position = position;
+        this.size = size;
+        this.lines = lines;
+    }
+    
     /**
-     * Verifies that this chunk's saved text matches the corresponding
-     * text in the given sequence.
-     * @param target the sequence to verify against.
+     * Creates a chunk and saves a copy of affected lines
+     * 
+     * @param position
+     *            the start position
+     * @param size
+     *            the size of a Chunk
+     * @param lines
+     *            the affected lines
      */
-    public void verify(List<?> target) throws PatchFailedException{
+    public Chunk(int position, int size, Object[] lines) {
+        this.position = position;
+        this.size = size;
+        this.lines = Arrays.asList(lines);
+    }
+    
+    /**
+     * Verifies that this chunk's saved text matches the corresponding text in
+     * the given sequence.
+     * 
+     * @param target
+     *            the sequence to verify against.
+     */
+    public void verify(List<?> target) throws PatchFailedException {
         if (last() > target.size()) {
             throw new PatchFailedException("Incorrect Chunk: the position of chunk > target size");
         }
         for (int i = 0; i < size; i++) {
             if (!target.get(position + i).equals(lines.get(i))) {
-            	throw new PatchFailedException("Incorrect Chunk: the chunk content doesn't match the target");
+                throw new PatchFailedException(
+                        "Incorrect Chunk: the chunk content doesn't match the target");
             }
         }
     }
-	
-	/**
-	 * @return the start position of chunk in the text  
-	 */
-	public int getPosition() {
-		return position;
-	}
-	/**
-	 * @param position the start position to set
-	 */
-	public void setPosition(int position) {
-		this.position = position;
-	}
-	
-	/**
-	 * @return the size of Chunk (size of affected lines)
-	 */
-	public int getSize() {
-		return size;
-	}
-	/**
-	 * @param size the size of affected lines to set
-	 */
-	public void setSize(int size) {
-		this.size = size;
-	}
-	
-	/**
-	 * @return the affected lines
-	 */
-	public List<?> getLines() {
-		return lines;
-	}
-	/**
-	 * @param lines the affected lines to set
-	 */
-	public void setLines(List<?> lines) {
-		this.lines = lines;
-	}
-	
+    
+    /**
+     * @return the start position of chunk in the text
+     */
+    public int getPosition() {
+        return position;
+    }
+    
+    /**
+     * @param position
+     *            the start position to set
+     */
+    public void setPosition(int position) {
+        this.position = position;
+    }
+    
+    /**
+     * @return the size of Chunk (size of affected lines)
+     */
+    public int getSize() {
+        return size;
+    }
+    
+    /**
+     * @param size
+     *            the size of affected lines to set
+     */
+    public void setSize(int size) {
+        this.size = size;
+    }
+    
+    /**
+     * @return the affected lines
+     */
+    public List<?> getLines() {
+        return lines;
+    }
+    
+    /**
+     * @param lines
+     *            the affected lines to set
+     */
+    public void setLines(List<?> lines) {
+        this.lines = lines;
+    }
+    
     /**
      * Returns the index of the last line of the chunk.
      */
-    public int last(){
+    public int last() {
         return getPosition() + getSize() - 1;
     }
-
-	/* (non-Javadoc)
-	 * @see java.lang.Object#hashCode()
-	 */
-	@Override
-	public int hashCode() {
-		final int prime = 31;
-		int result = 1;
-		result = prime * result + ((lines == null) ? 0 : lines.hashCode());
-		result = prime * result + position;
-		result = prime * result + size;
-		return result;
-	}
-
-	/* (non-Javadoc)
-	 * @see java.lang.Object#equals(java.lang.Object)
-	 */
-	@Override
-	public boolean equals(Object obj) {
-		if (this == obj)
-			return true;
-		if (obj == null)
-			return false;
-		if (getClass() != obj.getClass())
-			return false;
-		Chunk other = (Chunk) obj;
-		if (lines == null) {
-			if (other.lines != null)
-				return false;
-		} else if (!lines.equals(other.lines))
-			return false;
-		if (position != other.position)
-			return false;
-		if (size != other.size)
-			return false;
-		return true;
-	}
-	
-	@Override
-	public String toString() {
-		return "[position: " + position + ", size: " + size + ", lines: " + lines + "]";
-	}
-	
+    
+    /*
+     * (non-Javadoc)
+     * 
+     * @see java.lang.Object#hashCode()
+     */
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + ((lines == null) ? 0 : lines.hashCode());
+        result = prime * result + position;
+        result = prime * result + size;
+        return result;
+    }
+    
+    /*
+     * (non-Javadoc)
+     * 
+     * @see java.lang.Object#equals(java.lang.Object)
+     */
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        Chunk other = (Chunk) obj;
+        if (lines == null) {
+            if (other.lines != null)
+                return false;
+        } else if (!lines.equals(other.lines))
+            return false;
+        if (position != other.position)
+            return false;
+        if (size != other.size)
+            return false;
+        return true;
+    }
+    
+    @Override
+    public String toString() {
+        return "[position: " + position + ", size: " + size + ", lines: " + lines + "]";
+    }
+    
 }
diff --git a/src/difflib/DeleteDelta.java b/src/difflib/DeleteDelta.java
index 6a0ee71..f9d9c87 100644
--- a/src/difflib/DeleteDelta.java
+++ b/src/difflib/DeleteDelta.java
@@ -15,7 +15,7 @@
 
     You should have received a copy of the GNU General Public License
     along with Java Diff Utills Library.  If not, see <http://www.gnu.org/licenses/>.
-*/
+ */
 package difflib;
 
 import java.util.List;
@@ -26,48 +26,49 @@
  * @author <a href="dm.naumenko@gmail.com">Dmitry Naumenko</a>
  */
 public class DeleteDelta extends Delta {
-
-	/**
-	 * {@inheritDoc}
-	 */
-	public DeleteDelta(Chunk original, Chunk revised) {
-		super(original, revised);
-	}
-
-	/**
-	 * {@inheritDoc}
-	 * @throws PatchFailedException 
-	 */
-	@Override
-	public void applyTo(List<Object> target) throws PatchFailedException {
-		verify(target);
-		int position = getOriginal().getPosition();
-		int size = getOriginal().getSize();
-		for (int i = 0; i < size; i++) {
-			target.remove(position);
-		}
-	}
-
-	/**
-	 * {@inheritDoc}
-	 */
-	@Override
-	public void restore(List<Object> target) {
-		int position = this.getRevised().getPosition(); 
-		List<?> lines = this.getOriginal().getLines();
-		for (int i = 0; i < lines.size(); i++) {
-			target.add(position + i, lines.get(i));
-		}
-	}
-
-	@Override
-	public void verify(List<?> target) throws PatchFailedException {
-		getOriginal().verify(target);
-	}
-	
-	@Override
-	public String toString() {
-		return "[DeleteDelta, position: " + getOriginal().getPosition() + ", lines: " + 
-			getOriginal().getLines() + "]"; 
-	}
+    
+    /**
+     * {@inheritDoc}
+     */
+    public DeleteDelta(Chunk original, Chunk revised) {
+        super(original, revised);
+    }
+    
+    /**
+     * {@inheritDoc}
+     * 
+     * @throws PatchFailedException
+     */
+    @Override
+    public void applyTo(List<Object> target) throws PatchFailedException {
+        verify(target);
+        int position = getOriginal().getPosition();
+        int size = getOriginal().getSize();
+        for (int i = 0; i < size; i++) {
+            target.remove(position);
+        }
+    }
+    
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void restore(List<Object> target) {
+        int position = this.getRevised().getPosition();
+        List<?> lines = this.getOriginal().getLines();
+        for (int i = 0; i < lines.size(); i++) {
+            target.add(position + i, lines.get(i));
+        }
+    }
+    
+    @Override
+    public void verify(List<?> target) throws PatchFailedException {
+        getOriginal().verify(target);
+    }
+    
+    @Override
+    public String toString() {
+        return "[DeleteDelta, position: " + getOriginal().getPosition() + ", lines: "
+                + getOriginal().getLines() + "]";
+    }
 }
diff --git a/src/difflib/Delta.java b/src/difflib/Delta.java
index 58242e7..aaa5bc6 100644
--- a/src/difflib/Delta.java
+++ b/src/difflib/Delta.java
@@ -15,7 +15,7 @@
 
     You should have received a copy of the GNU General Public License
     along with Java Diff Utills Library.  If not, see <http://www.gnu.org/licenses/>.
-*/
+ */
 package difflib;
 
 import java.util.*;
@@ -26,105 +26,111 @@
  * @author <a href="dm.naumenko@gmail.com">Dmitry Naumenko</a>
  */
 public abstract class Delta {
-	private Chunk original;
-	private Chunk revised;
-
-	/**
-	 * Construct the delta for original and revised chunks
-	 * 
-	 * @param original chunk describes the original text
-	 * @param revised chunk describes the revised text
-	 */
-	public Delta(Chunk original, Chunk revised) {
-		this.original = original;
-		this.revised  = revised;
-	}
-	
+    private Chunk original;
+    private Chunk revised;
+    
+    /**
+     * Construct the delta for original and revised chunks
+     * 
+     * @param original chunk describes the original text
+     * @param revised chunk describes the revised text
+     */
+    public Delta(Chunk original, Chunk revised) {
+        this.original = original;
+        this.revised = revised;
+    }
+    
     /**
      * Verifies that this delta can be used to patch the given text.
+     * 
      * @param target the text to patch.
      * @throws PatchFailedException if the patch cannot be applied.
      */
     public abstract void verify(List<?> target) throws PatchFailedException;
-	
-	/**
-	 * Applies this delta as the patch for a given target
-	 * 
-	 * @param target the given target
-	 * @throws PatchFailedException  
-	 */
-	public abstract void applyTo(List<Object> target) throws PatchFailedException;
-	
-	/**
-	 * Cancel this delta for a given revised text. The action is opposite to patch.
-	 * 
-	 * @param target the given revised text
-	 */
-	public abstract void restore(List<Object> target);
-	
-	/**
-	 * @return the Chunk describing the original text
-	 */
-	public Chunk getOriginal() {
-		return original;
-	}
-	/**
-	 * @param original the Chunk describing the original text to set
-	 */
-	public void setOriginal(Chunk original) {
-		this.original = original;
-	}
-	
-	/**
-	 * @return the Chunk describing the revised text
-	 */
-	public Chunk getRevised() {
-		return revised;
-	}
-	/**
-	 * @param revised the Chunk describing the revised text to set
-	 */
-	public void setRevised(Chunk revised) {
-		this.revised = revised;
-	}
-
-	/* (non-Javadoc)
-	 * @see java.lang.Object#hashCode()
-	 */
-	@Override
-	public int hashCode() {
-		final int prime = 31;
-		int result = 1;
-		result = prime * result
-				+ ((original == null) ? 0 : original.hashCode());
-		result = prime * result + ((revised == null) ? 0 : revised.hashCode());
-		return result;
-	}
-
-	/* (non-Javadoc)
-	 * @see java.lang.Object#equals(java.lang.Object)
-	 */
-	@Override
-	public boolean equals(Object obj) {
-		if (this == obj)
-			return true;
-		if (obj == null)
-			return false;
-		if (getClass() != obj.getClass())
-			return false;
-		Delta other = (Delta) obj;
-		if (original == null) {
-			if (other.original != null)
-				return false;
-		} else if (!original.equals(other.original))
-			return false;
-		if (revised == null) {
-			if (other.revised != null)
-				return false;
-		} else if (!revised.equals(other.revised))
-			return false;
-		return true;
-	}
-	
-	
+    
+    /**
+     * Applies this delta as the patch for a given target
+     * 
+     * @param target the given target
+     * @throws PatchFailedException
+     */
+    public abstract void applyTo(List<Object> target) throws PatchFailedException;
+    
+    /**
+     * Cancel this delta for a given revised text. The action is opposite to
+     * patch.
+     * 
+     * @param target the given revised text
+     */
+    public abstract void restore(List<Object> target);
+    
+    /**
+     * @return the Chunk describing the original text
+     */
+    public Chunk getOriginal() {
+        return original;
+    }
+    
+    /**
+     * @param original the Chunk describing the original text to set
+     */
+    public void setOriginal(Chunk original) {
+        this.original = original;
+    }
+    
+    /**
+     * @return the Chunk describing the revised text
+     */
+    public Chunk getRevised() {
+        return revised;
+    }
+    
+    /**
+     * @param revised the Chunk describing the revised text to set
+     */
+    public void setRevised(Chunk revised) {
+        this.revised = revised;
+    }
+    
+    /*
+     * (non-Javadoc)
+     * 
+     * @see java.lang.Object#hashCode()
+     */
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + ((original == null) ? 0 : original.hashCode());
+        result = prime * result + ((revised == null) ? 0 : revised.hashCode());
+        return result;
+    }
+    
+    /*
+     * (non-Javadoc)
+     * 
+     * @see java.lang.Object#equals(java.lang.Object)
+     */
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        Delta other = (Delta) obj;
+        if (original == null) {
+            if (other.original != null)
+                return false;
+        } else if (!original.equals(other.original))
+            return false;
+        if (revised == null) {
+            if (other.revised != null)
+                return false;
+        } else if (!revised.equals(other.revised))
+            return false;
+        return true;
+    }
+    
 }
diff --git a/src/difflib/DiffAlgorithm.java b/src/difflib/DiffAlgorithm.java
index 1a71695..b9806de 100644
--- a/src/difflib/DiffAlgorithm.java
+++ b/src/difflib/DiffAlgorithm.java
@@ -15,7 +15,7 @@
 
     You should have received a copy of the GNU General Public License
     along with Java Diff Utills Library.  If not, see <http://www.gnu.org/licenses/>.
-*/
+ */
 package difflib;
 
 import java.util.*;
@@ -26,26 +26,24 @@
  * @author <a href="dm.naumenko@gmail.com">Dmitry Naumenko</a>
  */
 public interface DiffAlgorithm {
-	
+    
     /**
-     * Computes the difference between the original
-     * sequence and the revised sequence and returns it
-     * as a {@link difflib.Patch Patch} object.
-     *
+     * Computes the difference between the original sequence and the revised
+     * sequence and returns it as a {@link difflib.Patch Patch} object.
+     * 
      * @param original the original text
      * @param revised the revised text
      * @return the patch
      */
-	public Patch diff(Object[] original, Object[] revised);
-	
+    public Patch diff(Object[] original, Object[] revised);
+    
     /**
-     * Computes the difference between the original
-     * sequence and the revised sequence and returns it
-     * as a {@link difflib.Patch Patch} object.
-     *
+     * Computes the difference between the original sequence and the revised
+     * sequence and returns it as a {@link difflib.Patch Patch} object.
+     * 
      * @param original the original text
      * @param revised the revised text
      * @return the patch
      */
-	public Patch diff(List<?> original, List<?> revised);
+    public Patch diff(List<?> original, List<?> revised);
 }
diff --git a/src/difflib/DiffException.java b/src/difflib/DiffException.java
index 5bcf9da..ac0b1ed 100644
--- a/src/difflib/DiffException.java
+++ b/src/difflib/DiffException.java
@@ -15,23 +15,22 @@
 
     You should have received a copy of the GNU General Public License
     along with Java Diff Utills Library.  If not, see <http://www.gnu.org/licenses/>.
-*/
+ */
 package difflib;
 
 /**
  * Base class for all exceptions emanating from this package.
- *
+ * 
  * @author <a href="mailto:juanco@suigeneris.org">Juanco Anez</a>
  */
 public class DiffException extends Exception {
-
-	private static final long serialVersionUID = 1L;
-
-	public DiffException() {
+    
+    private static final long serialVersionUID = 1L;
+    
+    public DiffException() {
     }
-
+    
     public DiffException(String msg) {
         super(msg);
     }
 }
-
diff --git a/src/difflib/DiffRow.java b/src/difflib/DiffRow.java
index 444980c..7cd3acc 100644
--- a/src/difflib/DiffRow.java
+++ b/src/difflib/DiffRow.java
@@ -15,112 +15,120 @@
 
     You should have received a copy of the GNU General Public License
     along with Java Diff Utills Library.  If not, see <http://www.gnu.org/licenses/>.
-*/
+ */
 package difflib;
 
 /**
- * Describes the diff row in form [tag, oldLine, newLine) for showing the difference between two
- * texts 
+ * Describes the diff row in form [tag, oldLine, newLine) for showing the
+ * difference between two texts
  * 
  * @author <a href="dm.naumenko@gmail.com">Dmitry Naumenko</a>
  */
 public class DiffRow {
-	private Tag tag;
-	private String oldLine;
-	private String newLine;
-	
-	public DiffRow(Tag tag, String oldLine, String newLine) {
-		this.tag = tag;
-		this.oldLine = oldLine;
-		this.newLine = newLine;
-	}
-	
-	public enum Tag {
-		INSERT, DELETE, CHANGE, EQUAL
-	}
-	
-	/**
-	 * @return the tag
-	 */
-	public Tag getTag() {
-		return tag;
-	}
-	/**
-	 * @param tag the tag to set
-	 */
-	public void setTag(Tag tag) {
-		this.tag = tag;
-	}
-	
-	/**
-	 * @return the oldLine
-	 */
-	public String getOldLine() {
-		return oldLine;
-	}
-	/**
-	 * @param oldLine the oldLine to set
-	 */
-	public void setOldLine(String oldLine) {
-		this.oldLine = oldLine;
-	}
-	
-	/**
-	 * @return the newLine
-	 */
-	public String getNewLine() {
-		return newLine;
-	}
-	/**
-	 * @param newLine the newLine to set
-	 */
-	public void setNewLine(String newLine) {
-		this.newLine = newLine;
-	}
-	
-	/* (non-Javadoc)
-	 * @see java.lang.Object#hashCode()
-	 */
-	@Override
-	public int hashCode() {
-		final int prime = 31;
-		int result = 1;
-		result = prime * result + ((newLine == null) ? 0 : newLine.hashCode());
-		result = prime * result + ((oldLine == null) ? 0 : oldLine.hashCode());
-		result = prime * result + ((tag == null) ? 0 : tag.hashCode());
-		return result;
-	}
-	/* (non-Javadoc)
-	 * @see java.lang.Object#equals(java.lang.Object)
-	 */
-	@Override
-	public boolean equals(Object obj) {
-		if (this == obj)
-			return true;
-		if (obj == null)
-			return false;
-		if (getClass() != obj.getClass())
-			return false;
-		DiffRow other = (DiffRow) obj;
-		if (newLine == null) {
-			if (other.newLine != null)
-				return false;
-		} else if (!newLine.equals(other.newLine))
-			return false;
-		if (oldLine == null) {
-			if (other.oldLine != null)
-				return false;
-		} else if (!oldLine.equals(other.oldLine))
-			return false;
-		if (tag == null) {
-			if (other.tag != null)
-				return false;
-		} else if (!tag.equals(other.tag))
-			return false;
-		return true;
-	}
-	
-	public String toString() {
-		return "[" + this.tag + "," + this.oldLine + "," + this.newLine  + "]";
-	}
+    private Tag tag;
+    private String oldLine;
+    private String newLine;
+    
+    public DiffRow(Tag tag, String oldLine, String newLine) {
+        this.tag = tag;
+        this.oldLine = oldLine;
+        this.newLine = newLine;
+    }
+    
+    public enum Tag {
+        INSERT, DELETE, CHANGE, EQUAL
+    }
+    
+    /**
+     * @return the tag
+     */
+    public Tag getTag() {
+        return tag;
+    }
+    
+    /**
+     * @param tag the tag to set
+     */
+    public void setTag(Tag tag) {
+        this.tag = tag;
+    }
+    
+    /**
+     * @return the oldLine
+     */
+    public String getOldLine() {
+        return oldLine;
+    }
+    
+    /**
+     * @param oldLine the oldLine to set
+     */
+    public void setOldLine(String oldLine) {
+        this.oldLine = oldLine;
+    }
+    
+    /**
+     * @return the newLine
+     */
+    public String getNewLine() {
+        return newLine;
+    }
+    
+    /**
+     * @param newLine the newLine to set
+     */
+    public void setNewLine(String newLine) {
+        this.newLine = newLine;
+    }
+    
+    /*
+     * (non-Javadoc)
+     * 
+     * @see java.lang.Object#hashCode()
+     */
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + ((newLine == null) ? 0 : newLine.hashCode());
+        result = prime * result + ((oldLine == null) ? 0 : oldLine.hashCode());
+        result = prime * result + ((tag == null) ? 0 : tag.hashCode());
+        return result;
+    }
+    
+    /*
+     * (non-Javadoc)
+     * 
+     * @see java.lang.Object#equals(java.lang.Object)
+     */
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        DiffRow other = (DiffRow) obj;
+        if (newLine == null) {
+            if (other.newLine != null)
+                return false;
+        } else if (!newLine.equals(other.newLine))
+            return false;
+        if (oldLine == null) {
+            if (other.oldLine != null)
+                return false;
+        } else if (!oldLine.equals(other.oldLine))
+            return false;
+        if (tag == null) {
+            if (other.tag != null)
+                return false;
+        } else if (!tag.equals(other.tag))
+            return false;
+        return true;
+    }
+    
+    public String toString() {
+        return "[" + this.tag + "," + this.oldLine + "," + this.newLine + "]";
+    }
 }
diff --git a/src/difflib/DiffRowGenerator.java b/src/difflib/DiffRowGenerator.java
index da79dd4..77aa3fb 100644
--- a/src/difflib/DiffRowGenerator.java
+++ b/src/difflib/DiffRowGenerator.java
@@ -15,7 +15,7 @@
 
     You should have received a copy of the GNU General Public License
     along with Java Diff Utills Library.  If not, see <http://www.gnu.org/licenses/>.
-*/
+ */
 package difflib;
 
 import java.util.ArrayList;
@@ -48,358 +48,357 @@
  * @author <a href="dm.naumenko@gmail.com">Dmitry Naumenko</a>
   */
 public class DiffRowGenerator {
-	private final boolean showInlineDiffs;
-	private final boolean ignoreWhiteSpaces;
-	private final boolean ignoreBlankLines;
-	private final String  InlineOldTag;
-	private final String  InlineNewTag;
-	private final String  InlineOldCssClass;
-	private final String  InlineNewCssClass;
-	private final int  columnWidth;
-	
-	/**
-	 * This class used for building the DiffRowGenerator.
-	 * @author dmitry
-	 *
-	 */
-	public static class Builder {
-		private boolean showInlineDiffs = false;
-		private boolean ignoreWhiteSpaces = true;
-		private boolean ignoreBlankLines = true;
-		private String  InlineOldTag = "span";
-		private String  InlineNewTag = "span";
-		private String  InlineOldCssClass = "editOldInline";
-		private String  InlineNewCssClass = "editNewInline";
-		private int  columnWidth = 80;
-		
-		/**
-		 * Show inline diffs in generating diff rows or not.
-		 * @param val the value to set. Default: false.
-		 * @return builder with configured showInlineDiff parameter 
-		 */
-		public Builder showInlineDiffs(boolean val) {
-			showInlineDiffs = val;
-			return this;
-		}
-		
-		/**
-		 * Ignore white spaces in generating diff rows or not.
-		 * @param val the value to set. Default: true.
-		 * @return builder with configured ignoreWhiteSpaces parameter
-		 */
-		public Builder ignoreWhiteSpaces(boolean val) {
-			ignoreWhiteSpaces = val;
-			return this;
-		}
-		
-		/**
-		 * Ignore blank lines in generating diff rows or not.
-		 * @param val the value to set. Default: true.
-		 * @return builder with configured ignoreBlankLines parameter
-		 */
-		public Builder ignoreBlankLines(boolean val) {
-			ignoreBlankLines = val;
-			return this;
-		}
-		
-		/**
-		 * Set the tag used for displaying changes in the original text.
-		 * @param tag the tag to set. Without angle brackets. Default: span.
-		 * @return builder with configured ignoreBlankLines parameter
-		 */
-		public Builder InlineOldTag(String tag) {
-			InlineOldTag = tag;
-			return this;
-		}
-		
-		/**
-		 * Set the tag used for displaying changes in the revised text.
-		 * @param tag the tag to set. Without angle brackets. Default: span.
-		 * @return builder with configured ignoreBlankLines parameter
-		 */
-		public Builder InlineNewTag(String tag) {
-			InlineNewTag = tag;
-			return this;
-		}
-		
-		/**
-		 * Set the css class used for displaying changes in the original text.
-		 * @param cssClass the tag to set. Without any quotes, just word. Default: editOldInline.
-		 * @return builder with configured ignoreBlankLines parameter
-		 */
-		public Builder InlineOldCssClass(String cssClass) {
-			InlineOldCssClass = cssClass;
-			return this;
-		}
-		
-		/**
-		 * Set the css class used for displaying changes in the revised text.
-		 * @param cssClass the tag to set. Without any quotes, just word. Default: editNewInline.
-		 * @return builder with configured ignoreBlankLines parameter
-		 */
-		public Builder InlineNewCssClass(String cssClass) {
-			InlineNewCssClass = cssClass;
-			return this;
-		}
-		
-		/**
-		 * Set the column with of generated lines of original and revised texts.
-		 * @param width the width to set. Making it < 0 doesn't have any sense. Default 80.
-		 * @return builder with configured ignoreBlankLines parameter
-		 */
-		public Builder columnWidth(int width) {
-			if (width > 0) {
-				columnWidth = width;
-			}
-			return this;
-		}
-		
-		/**
-		 * Build the DiffRowGenerator. If some parameters is not set, the default values are used.
-		 * @return the customized DiffRowGenerator
-		 */
-		public DiffRowGenerator build() {
-			return new DiffRowGenerator(this);
-		}
-	}
-	
-	private DiffRowGenerator(Builder builder) {
-		showInlineDiffs = builder.showInlineDiffs;
-		ignoreWhiteSpaces = builder.ignoreWhiteSpaces; //
-		ignoreBlankLines = builder.ignoreBlankLines; //
-		InlineOldTag = builder.InlineOldTag;
-		InlineNewTag = builder.InlineNewTag;
-		InlineOldCssClass = builder.InlineOldCssClass;
-		InlineNewCssClass = builder.InlineNewCssClass;
-		columnWidth = builder.columnWidth; //
-	}
-	
-	/**
-	 * Get the DiffRows describing the difference between original and revised texts using the
-	 * given patch. Useful for displaying side-by-side diff.
-	 * 
-	 * @param original the original text
-	 * @param revised the revised text 
-	 * @return the DiffRows between original and revised texts
-	 */
-	public List<DiffRow> generateDiffRows(List<String> original, List<String> revised) {
-		return generateDiffRows(original, revised, DiffUtils.diff(original, revised));
-	}
-	
-	/**
-	 * Generates the DiffRows describing the difference between original and revised texts using the
-	 * given patch. Useful for displaying side-by-side diff.
-	 * 
-	 * @param original the original text
-	 * @param revised the revised text
-	 * @param patch the given patch 
-	 * @return the DiffRows between original and revised texts
-	 */
-	@SuppressWarnings("unchecked")
-	public List<DiffRow> generateDiffRows(List<String> original, List<String> revised, Patch patch) {
-		// normalize the lines (expand tabs, escape html entities)
-		original = StringUtills.normalize((List<String>)original);
-		revised  = StringUtills.normalize((List<String>)revised);
-		
-		// wrap to the column width
-		original = StringUtills.wrapText((List<String>)original, this.columnWidth);
-		revised  = StringUtills.wrapText((List<String>)revised, this.columnWidth);
-		
-		List<DiffRow> diffRows = new ArrayList<DiffRow>();
-		int endPos = 0;
-		for (int i = 0; i < patch.getDeltas().size(); i++) {
-			Delta delta = patch.getDelta(i);
-			Chunk orig = delta.getOriginal();
-			Chunk rev = delta.getRevised();
-			
-			// We should normalize and wrap lines in deltas too.
-			orig.setLines(StringUtills.normalize((List<String>)orig.getLines()));
-			rev.setLines(StringUtills.normalize((List<String>)rev.getLines()));
-			
-			orig.setLines(StringUtills.wrapText((List<String>)orig.getLines(), this.columnWidth));
-			rev.setLines(StringUtills.wrapText((List<String>)rev.getLines(), this.columnWidth));
-			
-			// catch the equal prefix for each chunk
-			for (String line: original.subList(endPos, orig.getPosition())) {
-				diffRows.add(new DiffRow(Tag.EQUAL, line, line));
-			}
-			
-			// Inserted DiffRow
-			if (delta.getClass().equals(InsertDelta.class)) {
-				endPos = orig.last() + 1;
-				for (String line: (List<String>)rev.getLines()) {
-					diffRows.add(new DiffRow(Tag.INSERT, "", line));
-				}
-				continue;
-			}
-			
-			// Deleted DiffRow
-			if (delta.getClass().equals(DeleteDelta.class)) {
-				endPos = orig.last() + 1;
-				for (String line: (List<String>)orig.getLines()) {
-					diffRows.add(new DiffRow(Tag.DELETE, line, ""));
-				}
-				continue;
-			}
-			
-			if (showInlineDiffs) {
-				addInlineDiffs(delta);
-			}
-		    // the changed size is match
-		    if (orig.getSize() == rev.getSize()) {
-		    	for (int j = 0; j < orig.getSize(); j++) {
-		    		diffRows.add(new DiffRow(Tag.CHANGE, (String)orig.getLines().get(j), 
-		    				(String)rev.getLines().get(j)));
-		    	}
-		    } else if (orig.getSize() > rev.getSize()) {
-		    	for (int j = 0; j < orig.getSize(); j++) {
-		    		diffRows.add(new DiffRow(Tag.CHANGE, (String)orig.getLines().get(j), 
-		    				rev.getLines().size() > j ? (String)rev.getLines().get(j) : ""));
-		    	}
-		    } else {
-		    	for (int j = 0; j < rev.getSize(); j++) {
-		    		diffRows.add(new DiffRow(Tag.CHANGE, orig.getLines().size() > j ? 
-		    				(String)orig.getLines().get(j) : "", (String)rev.getLines().get(j)));
-		    	}
-		    }
-		    endPos = orig.last() + 1;
-		}
-		
-		// Copy the final matching chunk if any.
-		for (String line: original.subList(endPos, original.size())) {
-			diffRows.add(new DiffRow(Tag.EQUAL, line, line));
-		}
-		return diffRows;
-	}
-	
-	/**
-	 * Add the inline diffs for given delta
-	 * @param delta the given delta
-	 */
-	@SuppressWarnings("unchecked")
-	private void addInlineDiffs(Delta delta) {
-		List<String> orig = (List<String>)delta.getOriginal().getLines();
-		List<String> rev = (List<String>)delta.getRevised().getLines();
-		LinkedList<String> origList = new LinkedList<String>();
-		for (Character character: join(orig, "\n").toCharArray()) {
-			origList.add(character.toString());
-		}
-		LinkedList<String> revList = new LinkedList<String>();
-		for (Character character: join(rev, "\n").toCharArray()) {
-			revList.add(character.toString());
-		}
-		List<Delta> inlineDeltas = DiffUtils.diff(origList, revList).getDeltas();
-		if (inlineDeltas.size() < 3) {
-			Collections.reverse(inlineDeltas);
-			for (Delta inlineDelta: inlineDeltas) {
-		    	Chunk inlineOrig = inlineDelta.getOriginal();
-				Chunk inlineRev = inlineDelta.getRevised();
-				if (inlineDelta.getClass().equals(DeleteDelta.class)) {
-					origList = wrapInTag(origList, inlineOrig.getPosition(),
-							inlineOrig.getPosition() + inlineOrig.getSize() + 1, 
-							this.InlineOldTag, this.InlineOldCssClass);
-				} else if (inlineDelta.getClass().equals(InsertDelta.class)) {
-					revList = wrapInTag(revList, inlineRev.getPosition(),
-							  inlineRev.getPosition() + inlineRev.getSize() + 1, 
-							  this.InlineNewTag, this.InlineNewCssClass);
-				} else if (inlineDelta.getClass().equals(ChangeDelta.class)) {
-					origList = wrapInTag(origList, inlineOrig.getPosition(),
-							inlineOrig.getPosition() + inlineOrig.getSize() + 1, 
-							this.InlineOldTag, this.InlineOldCssClass);
-					revList = wrapInTag(revList, inlineRev.getPosition(),
-							  inlineRev.getPosition() + inlineRev.getSize() + 1, 
-							this.InlineNewTag, this.InlineNewCssClass);
-				}
-			}
-			StringBuilder origResult = new StringBuilder(), revResult = new StringBuilder();
-			for (String character: origList) {
-				origResult.append(character);
-			}
-			for (String character: revList) {
-				revResult.append(character);
-			}
-			delta.getOriginal().setLines(Arrays.asList(origResult.toString().split("\n")));
-			delta.getRevised().setLines(Arrays.asList(revResult.toString().split("\n")));
-		}
-	}
-	
-	/**
-	 * Wrap the elements in the sequence with the given tag
-	 * @param startPosition the position from which tag should start. The counting start from a zero.
-	 * @param endPosition the position before which tag should should be closed. 
-	 * @param tag the tag name without angle brackets, just a word 
-	 * @param cssClass the optional css class
-	 */
-	public static LinkedList<String> wrapInTag(LinkedList<String> sequence, int startPosition, int endPosition, String tag, String cssClass) {
-		LinkedList<String> result = (LinkedList<String>)sequence.clone();
-		StringBuilder tagBuilder = new StringBuilder();
-		tagBuilder.append("<");
-		tagBuilder.append(tag);
-		if (cssClass != null) {
-			tagBuilder.append(" class=\"");
-			tagBuilder.append(cssClass);
-			tagBuilder.append("\"");
-		}
-		tagBuilder.append(">");
-		String startTag = tagBuilder.toString();
-		
-		tagBuilder.delete(0, tagBuilder.length());
-		
-		tagBuilder.append("</");
-		tagBuilder.append(tag);
-		tagBuilder.append(">");
-		String endTag = tagBuilder.toString();
-		
-		result.add(startPosition, startTag);
-		result.add(endPosition, endTag);
-		return result;
-	}
-	
-	/**
-	 * Wrap the given line with the given tag
-	 * @param line the given line
-	 * @param tag the tag name without angle brackets, just a word 
-	 * @param cssClass the optional css class
-	 * @return the wrapped string
-	 */
-	public static String wrapInTag(String line, String tag, String cssClass) {
-		StringBuilder tagBuilder = new StringBuilder();
-		tagBuilder.append("<");
-		tagBuilder.append(tag);
-		if (cssClass != null) {
-			tagBuilder.append(" class=\"");
-			tagBuilder.append(cssClass);
-			tagBuilder.append("\"");
-		}
-		tagBuilder.append(">");
-		String startTag = tagBuilder.toString();
-		
-		tagBuilder.delete(0, tagBuilder.length());
-		
-		tagBuilder.append("</");
-		tagBuilder.append(tag);
-		tagBuilder.append(">");
-		String endTag = tagBuilder.toString();
-		
-		return startTag + line + endTag;
-	}
-	
-	/**
-	 * The helper method for joining collections
-	 * @param <T>
-	 * @param objs the collection to join
-	 * @param delimiter the delimiter to use
-	 * @return the joined string
-	 */
-	private static <T> String join(final Iterable<T> objs, final String delimiter) {
-	    Iterator<T> iter = objs.iterator();
-	    if (!iter.hasNext()) {
-	        return "";
-	    }
-	    StringBuffer buffer = new StringBuffer(String.valueOf(iter.next()));
-	    while (iter.hasNext()) {
-	        buffer.append(delimiter).append(String.valueOf(iter.next()));
-	    }
-	    return buffer.toString();
-	}
+    private final boolean showInlineDiffs;
+    private final boolean ignoreWhiteSpaces;
+    private final boolean ignoreBlankLines;
+    private final String InlineOldTag;
+    private final String InlineNewTag;
+    private final String InlineOldCssClass;
+    private final String InlineNewCssClass;
+    private final int columnWidth;
+    
+    /**
+     * This class used for building the DiffRowGenerator.
+     * @author dmitry
+     *
+     */
+    public static class Builder {
+        private boolean showInlineDiffs = false;
+        private boolean ignoreWhiteSpaces = true;
+        private boolean ignoreBlankLines = true;
+        private String InlineOldTag = "span";
+        private String InlineNewTag = "span";
+        private String InlineOldCssClass = "editOldInline";
+        private String InlineNewCssClass = "editNewInline";
+        private int columnWidth = 80;
+        
+        /**
+         * Show inline diffs in generating diff rows or not.
+         * @param val the value to set. Default: false.
+         * @return builder with configured showInlineDiff parameter 
+         */
+        public Builder showInlineDiffs(boolean val) {
+            showInlineDiffs = val;
+            return this;
+        }
+        
+        /**
+         * Ignore white spaces in generating diff rows or not.
+         * @param val the value to set. Default: true.
+         * @return builder with configured ignoreWhiteSpaces parameter
+         */
+        public Builder ignoreWhiteSpaces(boolean val) {
+            ignoreWhiteSpaces = val;
+            return this;
+        }
+        
+        /**
+         * Ignore blank lines in generating diff rows or not.
+         * @param val the value to set. Default: true.
+         * @return builder with configured ignoreBlankLines parameter
+         */
+        public Builder ignoreBlankLines(boolean val) {
+            ignoreBlankLines = val;
+            return this;
+        }
+        
+        /**
+         * Set the tag used for displaying changes in the original text.
+         * @param tag the tag to set. Without angle brackets. Default: span.
+         * @return builder with configured ignoreBlankLines parameter
+         */
+        public Builder InlineOldTag(String tag) {
+            InlineOldTag = tag;
+            return this;
+        }
+        
+        /**
+         * Set the tag used for displaying changes in the revised text.
+         * @param tag the tag to set. Without angle brackets. Default: span.
+         * @return builder with configured ignoreBlankLines parameter
+         */
+        public Builder InlineNewTag(String tag) {
+            InlineNewTag = tag;
+            return this;
+        }
+        
+        /**
+         * Set the css class used for displaying changes in the original text.
+         * @param cssClass the tag to set. Without any quotes, just word. Default: editOldInline.
+         * @return builder with configured ignoreBlankLines parameter
+         */
+        public Builder InlineOldCssClass(String cssClass) {
+            InlineOldCssClass = cssClass;
+            return this;
+        }
+        
+        /**
+         * Set the css class used for displaying changes in the revised text.
+         * @param cssClass the tag to set. Without any quotes, just word. Default: editNewInline.
+         * @return builder with configured ignoreBlankLines parameter
+         */
+        public Builder InlineNewCssClass(String cssClass) {
+            InlineNewCssClass = cssClass;
+            return this;
+        }
+        
+        /**
+         * Set the column with of generated lines of original and revised texts.
+         * @param width the width to set. Making it < 0 doesn't have any sense. Default 80.
+         * @return builder with configured ignoreBlankLines parameter
+         */
+        public Builder columnWidth(int width) {
+            if (width > 0) {
+                columnWidth = width;
+            }
+            return this;
+        }
+        
+        /**
+         * Build the DiffRowGenerator. If some parameters is not set, the default values are used.
+         * @return the customized DiffRowGenerator
+         */
+        public DiffRowGenerator build() {
+            return new DiffRowGenerator(this);
+        }
+    }
+    
+    private DiffRowGenerator(Builder builder) {
+        showInlineDiffs = builder.showInlineDiffs;
+        ignoreWhiteSpaces = builder.ignoreWhiteSpaces; //
+        ignoreBlankLines = builder.ignoreBlankLines; //
+        InlineOldTag = builder.InlineOldTag;
+        InlineNewTag = builder.InlineNewTag;
+        InlineOldCssClass = builder.InlineOldCssClass;
+        InlineNewCssClass = builder.InlineNewCssClass;
+        columnWidth = builder.columnWidth; //
+    }
+    
+    /**
+     * Get the DiffRows describing the difference between original and revised texts using the
+     * given patch. Useful for displaying side-by-side diff.
+     * 
+     * @param original the original text
+     * @param revised the revised text 
+     * @return the DiffRows between original and revised texts
+     */
+    public List<DiffRow> generateDiffRows(List<String> original, List<String> revised) {
+        return generateDiffRows(original, revised, DiffUtils.diff(original, revised));
+    }
+    
+    /**
+     * Generates the DiffRows describing the difference between original and revised texts using the
+     * given patch. Useful for displaying side-by-side diff.
+     * 
+     * @param original the original text
+     * @param revised the revised text
+     * @param patch the given patch 
+     * @return the DiffRows between original and revised texts
+     */
+    @SuppressWarnings("unchecked")
+    public List<DiffRow> generateDiffRows(List<String> original, List<String> revised, Patch patch) {
+        // normalize the lines (expand tabs, escape html entities)
+        original = StringUtills.normalize((List<String>) original);
+        revised = StringUtills.normalize((List<String>) revised);
+        
+        // wrap to the column width
+        original = StringUtills.wrapText((List<String>) original, this.columnWidth);
+        revised = StringUtills.wrapText((List<String>) revised, this.columnWidth);
+        
+        List<DiffRow> diffRows = new ArrayList<DiffRow>();
+        int endPos = 0;
+        for (int i = 0; i < patch.getDeltas().size(); i++) {
+            Delta delta = patch.getDelta(i);
+            Chunk orig = delta.getOriginal();
+            Chunk rev = delta.getRevised();
+            
+            // We should normalize and wrap lines in deltas too.
+            orig.setLines(StringUtills.normalize((List<String>) orig.getLines()));
+            rev.setLines(StringUtills.normalize((List<String>) rev.getLines()));
+            
+            orig.setLines(StringUtills.wrapText((List<String>) orig.getLines(), this.columnWidth));
+            rev.setLines(StringUtills.wrapText((List<String>) rev.getLines(), this.columnWidth));
+            
+            // catch the equal prefix for each chunk
+            for (String line : original.subList(endPos, orig.getPosition())) {
+                diffRows.add(new DiffRow(Tag.EQUAL, line, line));
+            }
+            
+            // Inserted DiffRow
+            if (delta.getClass().equals(InsertDelta.class)) {
+                endPos = orig.last() + 1;
+                for (String line : (List<String>) rev.getLines()) {
+                    diffRows.add(new DiffRow(Tag.INSERT, "", line));
+                }
+                continue;
+            }
+            
+            // Deleted DiffRow
+            if (delta.getClass().equals(DeleteDelta.class)) {
+                endPos = orig.last() + 1;
+                for (String line : (List<String>) orig.getLines()) {
+                    diffRows.add(new DiffRow(Tag.DELETE, line, ""));
+                }
+                continue;
+            }
+            
+            if (showInlineDiffs) {
+                addInlineDiffs(delta);
+            }
+            // the changed size is match
+            if (orig.getSize() == rev.getSize()) {
+                for (int j = 0; j < orig.getSize(); j++) {
+                    diffRows.add(new DiffRow(Tag.CHANGE, (String) orig.getLines().get(j),
+                            (String) rev.getLines().get(j)));
+                }
+            } else if (orig.getSize() > rev.getSize()) {
+                for (int j = 0; j < orig.getSize(); j++) {
+                    diffRows.add(new DiffRow(Tag.CHANGE, (String) orig.getLines().get(j), rev
+                            .getLines().size() > j ? (String) rev.getLines().get(j) : ""));
+                }
+            } else {
+                for (int j = 0; j < rev.getSize(); j++) {
+                    diffRows.add(new DiffRow(Tag.CHANGE, orig.getLines().size() > j ? (String) orig
+                            .getLines().get(j) : "", (String) rev.getLines().get(j)));
+                }
+            }
+            endPos = orig.last() + 1;
+        }
+        
+        // Copy the final matching chunk if any.
+        for (String line : original.subList(endPos, original.size())) {
+            diffRows.add(new DiffRow(Tag.EQUAL, line, line));
+        }
+        return diffRows;
+    }
+    
+    /**
+     * Add the inline diffs for given delta
+     * @param delta the given delta
+     */
+    @SuppressWarnings("unchecked")
+    private void addInlineDiffs(Delta delta) {
+        List<String> orig = (List<String>) delta.getOriginal().getLines();
+        List<String> rev = (List<String>) delta.getRevised().getLines();
+        LinkedList<String> origList = new LinkedList<String>();
+        for (Character character : join(orig, "\n").toCharArray()) {
+            origList.add(character.toString());
+        }
+        LinkedList<String> revList = new LinkedList<String>();
+        for (Character character : join(rev, "\n").toCharArray()) {
+            revList.add(character.toString());
+        }
+        List<Delta> inlineDeltas = DiffUtils.diff(origList, revList).getDeltas();
+        if (inlineDeltas.size() < 3) {
+            Collections.reverse(inlineDeltas);
+            for (Delta inlineDelta : inlineDeltas) {
+                Chunk inlineOrig = inlineDelta.getOriginal();
+                Chunk inlineRev = inlineDelta.getRevised();
+                if (inlineDelta.getClass().equals(DeleteDelta.class)) {
+                    origList = wrapInTag(origList, inlineOrig.getPosition(), inlineOrig
+                            .getPosition()
+                            + inlineOrig.getSize() + 1, this.InlineOldTag, this.InlineOldCssClass);
+                } else if (inlineDelta.getClass().equals(InsertDelta.class)) {
+                    revList = wrapInTag(revList, inlineRev.getPosition(), inlineRev.getPosition()
+                            + inlineRev.getSize() + 1, this.InlineNewTag, this.InlineNewCssClass);
+                } else if (inlineDelta.getClass().equals(ChangeDelta.class)) {
+                    origList = wrapInTag(origList, inlineOrig.getPosition(), inlineOrig
+                            .getPosition()
+                            + inlineOrig.getSize() + 1, this.InlineOldTag, this.InlineOldCssClass);
+                    revList = wrapInTag(revList, inlineRev.getPosition(), inlineRev.getPosition()
+                            + inlineRev.getSize() + 1, this.InlineNewTag, this.InlineNewCssClass);
+                }
+            }
+            StringBuilder origResult = new StringBuilder(), revResult = new StringBuilder();
+            for (String character : origList) {
+                origResult.append(character);
+            }
+            for (String character : revList) {
+                revResult.append(character);
+            }
+            delta.getOriginal().setLines(Arrays.asList(origResult.toString().split("\n")));
+            delta.getRevised().setLines(Arrays.asList(revResult.toString().split("\n")));
+        }
+    }
+    
+    /**
+     * Wrap the elements in the sequence with the given tag
+     * @param startPosition the position from which tag should start. The counting start from a zero.
+     * @param endPosition the position before which tag should should be closed. 
+     * @param tag the tag name without angle brackets, just a word 
+     * @param cssClass the optional css class
+     */
+    public static LinkedList<String> wrapInTag(LinkedList<String> sequence, int startPosition,
+            int endPosition, String tag, String cssClass) {
+        LinkedList<String> result = (LinkedList<String>) sequence.clone();
+        StringBuilder tagBuilder = new StringBuilder();
+        tagBuilder.append("<");
+        tagBuilder.append(tag);
+        if (cssClass != null) {
+            tagBuilder.append(" class=\"");
+            tagBuilder.append(cssClass);
+            tagBuilder.append("\"");
+        }
+        tagBuilder.append(">");
+        String startTag = tagBuilder.toString();
+        
+        tagBuilder.delete(0, tagBuilder.length());
+        
+        tagBuilder.append("</");
+        tagBuilder.append(tag);
+        tagBuilder.append(">");
+        String endTag = tagBuilder.toString();
+        
+        result.add(startPosition, startTag);
+        result.add(endPosition, endTag);
+        return result;
+    }
+    
+    /**
+     * Wrap the given line with the given tag
+     * @param line the given line
+     * @param tag the tag name without angle brackets, just a word 
+     * @param cssClass the optional css class
+     * @return the wrapped string
+     */
+    public static String wrapInTag(String line, String tag, String cssClass) {
+        StringBuilder tagBuilder = new StringBuilder();
+        tagBuilder.append("<");
+        tagBuilder.append(tag);
+        if (cssClass != null) {
+            tagBuilder.append(" class=\"");
+            tagBuilder.append(cssClass);
+            tagBuilder.append("\"");
+        }
+        tagBuilder.append(">");
+        String startTag = tagBuilder.toString();
+        
+        tagBuilder.delete(0, tagBuilder.length());
+        
+        tagBuilder.append("</");
+        tagBuilder.append(tag);
+        tagBuilder.append(">");
+        String endTag = tagBuilder.toString();
+        
+        return startTag + line + endTag;
+    }
+    
+    /**
+     * The helper method for joining collections
+     * @param <T>
+     * @param objs the collection to join
+     * @param delimiter the delimiter to use
+     * @return the joined string
+     */
+    private static <T> String join(final Iterable<T> objs, final String delimiter) {
+        Iterator<T> iter = objs.iterator();
+        if (!iter.hasNext()) {
+            return "";
+        }
+        StringBuffer buffer = new StringBuffer(String.valueOf(iter.next()));
+        while (iter.hasNext()) {
+            buffer.append(delimiter).append(String.valueOf(iter.next()));
+        }
+        return buffer.toString();
+    }
 }
diff --git a/src/difflib/DiffUtils.java b/src/difflib/DiffUtils.java
index 479dca0..569d96a 100644
--- a/src/difflib/DiffUtils.java
+++ b/src/difflib/DiffUtils.java
@@ -15,7 +15,7 @@
 
     You should have received a copy of the GNU General Public License
     along with Java Diff Utills Library.  If not, see <http://www.gnu.org/licenses/>.
-*/
+ */
 package difflib;
 
 import java.util.*;
@@ -31,144 +31,313 @@
  * @version 0.4.1
  */
 public class DiffUtils {
-	private static DiffAlgorithm defaultDiffAlgorithm = new MyersDiff();
-	private static Pattern unifiedDiffChunkRe = 
-		Pattern.compile("@@\\s+-(?:(\\d+)(?:,(\\d+))?)\\s+\\+(?:(\\d+)(?:,(\\d+))?)\\s+@@");
-	
-	/**
-	 * Compute the difference between the original and revised texts with default diff algorithm 
-	 * 
-	 * @param original the original text
-	 * @param revised the revised text
-	 * @return the patch describing the difference between the original and revised texts 
-	 */
-	public static Patch diff(List<?> original, List<?> revised) {
-		return DiffUtils.diff(original, revised, defaultDiffAlgorithm);
-	}
-	
-	/**
-	 * Compute the difference between the original and revised texts with given diff algorithm 
-	 * 
-	 * @param original the original text
-	 * @param revised the revised text
-	 * @param algorithm the given algorithm
-	 * @return the patch describing the difference between the original and revised texts
-	 */
-	public static Patch diff(List<?> original, List<?> revised, DiffAlgorithm algorithm) {
-		return algorithm.diff(original, revised);
-	}
-	
-	/**
-	 * Patch the original text with given patch
-	 * 
-	 * @param original the original text
-	 * @param patch the given patch
-	 * @return the revised text
-	 * @throws PatchFailedException if can't apply patch
-	 */
-	public static List<?> patch(List<?> original, Patch patch) throws PatchFailedException {
-		return patch.applyTo(original);
-	}
-	
-	/**
-	 * Unpatch the revised text for a given patch
-	 * 
-	 * @param revised the revised text
-	 * @param patch the given patch
-	 * @return the original text
-	 */
-	public static List<?> unpatch(List<?> revised, Patch patch) {
-		return patch.restore(revised);
-	}
-	
-	/**
-	 * Parse the given text in unified format and creates the list of deltas for it.
-	 * 
-	 * @param diff the text in unified format 
-	 * @return the patch with deltas.
-	 */
-	public static Patch parseUnifiedDiff(List<String> diff) {
-		boolean inPrelude = true;
-		List<Object[]> rawChunk = new ArrayList<Object[]>();
-		Patch patch = new Patch();
-		
-		int old_ln = 0, old_n = 0, new_ln = 0, new_n = 0;
-		String tag = "", rest = "";
-		for (String line: diff) {
-			// Skip leading lines until after we've seen one starting with '+++'
-			if (inPrelude) {
-				if (line.startsWith("+++")) {
-					inPrelude = false;
-				}
-				continue;
-			}
-			Matcher m = unifiedDiffChunkRe.matcher(line);
-			if (m.find()) {
-				// Process the lines in the previous chunk
-				if (rawChunk.size() != 0) {
-					List<String> oldChunkLines = new ArrayList<String>();
-					List<String> newChunkLines = new ArrayList<String>();
-					
-					for (Object[] raw_line: rawChunk) {
-						tag = (String)raw_line[0];
-						rest = (String)raw_line[1];
-						if (tag.equals(" ") || tag.equals("-")) {
-							oldChunkLines.add(rest);
-						}
-						if (tag.equals(" ") || tag.equals("+")) {
-							newChunkLines.add(rest);
-						}
-					}
-					patch.addDelta(new ChangeDelta(new Chunk(old_ln - 1, old_n, oldChunkLines),  
-							new Chunk(new_ln - 1, new_n, newChunkLines)));
-					rawChunk.clear();
-				}
-				// Parse the @@ header
-				old_ln = m.group(1) == null ? 1 : Integer.parseInt(m.group(1));
-				old_n  = m.group(2) == null ? 1 : Integer.parseInt(m.group(2));
-				new_ln = m.group(3) == null ? 1 : Integer.parseInt(m.group(3));
-				new_n  = m.group(4) == null ? 1 : Integer.parseInt(m.group(4));
-				old_ln = Integer.parseInt(m.group(1));
-				
-				if (old_ln == 0) {
-					old_ln += 1; 
-				}
-				if (new_ln == 0) {
-					new_ln += 1;
-				}
-			} else {
-				if (line.length() > 0) {
-					tag  = line.substring(0, 1);
-					rest = line.substring(1);
-					if (tag.equals(" ") || tag.equals("+") || tag.equals("-")) {
-						rawChunk.add(new Object[] {tag, rest});
-					}
-				}
-			}
-		}
-		
-		// Process the lines in the last chunk
-		if (rawChunk.size() != 0) {
-			List<String> oldChunkLines = new ArrayList<String>();
-			List<String> newChunkLines = new ArrayList<String>();
-			
-			for (Object[] raw_line: rawChunk) {
-				tag = (String)raw_line[0];
-				rest = (String)raw_line[1];
-				if (tag.equals(" ") || tag.equals("-")) {
-					oldChunkLines.add(rest);
-				} 
-				if (tag.equals(" ") || tag.equals("+")) {
-					newChunkLines.add(rest);
-				}
-			}
-			
-			patch.addDelta(new ChangeDelta(new Chunk(old_ln - 1, old_n, oldChunkLines),  
-					new Chunk(new_ln - 1, new_n, newChunkLines)));
-			rawChunk.clear();
-		}
-		
-		return patch;
-	}
-	
+    private static DiffAlgorithm defaultDiffAlgorithm = new MyersDiff();
+    private static Pattern unifiedDiffChunkRe = 
+        Pattern.compile("@@\\s+-(?:(\\d+)(?:,(\\d+))?)\\s+\\+(?:(\\d+)(?:,(\\d+))?)\\s+@@");
+    
+    /**
+     * Compute the difference between the original and revised texts with default diff algorithm 
+     * 
+     * @param original the original text
+     * @param revised the revised text
+     * @return the patch describing the difference between the original and revised texts 
+     */
+    public static Patch diff(List<?> original, List<?> revised) {
+        return DiffUtils.diff(original, revised, defaultDiffAlgorithm);
+    }
+    
+    /**
+     * Compute the difference between the original and revised texts with given diff algorithm 
+     * 
+     * @param original the original text
+     * @param revised the revised text
+     * @param algorithm the given algorithm
+     * @return the patch describing the difference between the original and revised texts
+     */
+    public static Patch diff(List<?> original, List<?> revised, DiffAlgorithm algorithm) {
+        return algorithm.diff(original, revised);
+    }
+    
+    /**
+     * Patch the original text with given patch
+     * 
+     * @param original the original text
+     * @param patch the given patch
+     * @return the revised text
+     * @throws PatchFailedException if can't apply patch
+     */
+    public static List<?> patch(List<?> original, Patch patch) throws PatchFailedException {
+        return patch.applyTo(original);
+    }
+    
+    /**
+     * Unpatch the revised text for a given patch
+     * 
+     * @param revised the revised text
+     * @param patch the given patch
+     * @return the original text
+     */
+    public static List<?> unpatch(List<?> revised, Patch patch) {
+        return patch.restore(revised);
+    }
+    
+    /**
+     * Parse the given text in unified format and creates the list of deltas for it.
+     * 
+     * @param diff the text in unified format 
+     * @return the patch with deltas.
+     */
+    public static Patch parseUnifiedDiff(List<String> diff) {
+        boolean inPrelude = true;
+        List<Object[]> rawChunk = new ArrayList<Object[]>();
+        Patch patch = new Patch();
+        
+        int old_ln = 0, old_n = 0, new_ln = 0, new_n = 0;
+        String tag = "", rest = "";
+        for (String line : diff) {
+            // Skip leading lines until after we've seen one starting with '+++'
+            if (inPrelude) {
+                if (line.startsWith("+++")) {
+                    inPrelude = false;
+                }
+                continue;
+            }
+            Matcher m = unifiedDiffChunkRe.matcher(line);
+            if (m.find()) {
+                // Process the lines in the previous chunk
+                if (rawChunk.size() != 0) {
+                    List<String> oldChunkLines = new ArrayList<String>();
+                    List<String> newChunkLines = new ArrayList<String>();
+                    
+                    for (Object[] raw_line : rawChunk) {
+                        tag = (String) raw_line[0];
+                        rest = (String) raw_line[1];
+                        if (tag.equals(" ") || tag.equals("-")) {
+                            oldChunkLines.add(rest);
+                        }
+                        if (tag.equals(" ") || tag.equals("+")) {
+                            newChunkLines.add(rest);
+                        }
+                    }
+                    patch.addDelta(new ChangeDelta(new Chunk(old_ln - 1, old_n, oldChunkLines),
+                            new Chunk(new_ln - 1, new_n, newChunkLines)));
+                    rawChunk.clear();
+                }
+                // Parse the @@ header
+                old_ln = m.group(1) == null ? 1 : Integer.parseInt(m.group(1));
+                old_n = m.group(2) == null ? 1 : Integer.parseInt(m.group(2));
+                new_ln = m.group(3) == null ? 1 : Integer.parseInt(m.group(3));
+                new_n = m.group(4) == null ? 1 : Integer.parseInt(m.group(4));
+                old_ln = Integer.parseInt(m.group(1));
+                
+                if (old_ln == 0) {
+                    old_ln += 1;
+                }
+                if (new_ln == 0) {
+                    new_ln += 1;
+                }
+            } else {
+                if (line.length() > 0) {
+                    tag = line.substring(0, 1);
+                    rest = line.substring(1);
+                    if (tag.equals(" ") || tag.equals("+") || tag.equals("-")) {
+                        rawChunk.add(new Object[] { tag, rest });
+                    }
+                }
+            }
+        }
+        
+        // Process the lines in the last chunk
+        if (rawChunk.size() != 0) {
+            List<String> oldChunkLines = new ArrayList<String>();
+            List<String> newChunkLines = new ArrayList<String>();
+            
+            for (Object[] raw_line : rawChunk) {
+                tag = (String) raw_line[0];
+                rest = (String) raw_line[1];
+                if (tag.equals(" ") || tag.equals("-")) {
+                    oldChunkLines.add(rest);
+                }
+                if (tag.equals(" ") || tag.equals("+")) {
+                    newChunkLines.add(rest);
+                }
+            }
+            
+            patch.addDelta(new ChangeDelta(new Chunk(old_ln - 1, old_n, oldChunkLines), new Chunk(
+                    new_ln - 1, new_n, newChunkLines)));
+            rawChunk.clear();
+        }
+        
+        return patch;
+    }
+    
+    /**
+     * generateUnifiedDiff takes a Patch and some other arguments, returning the Unified Diff format text representing the Patch.
+     * @author Bill James (tankerbay@gmail.com)
+     * 
+     * @param original - Filename of the original (unrevised file)
+     * @param revised - Filename of the revised file
+     * @param originalLines - Lines of the original file
+     * @param patch - Patch created by the diff() function
+     * @param contextSize - number of lines of context output around each difference in the file.
+     * @return List of strings representing the Unified Diff representation of the Patch argument.
+     */
+    public static List<String> generateUnifiedDiff(String original, String revised,
+            List<String> originalLines, Patch patch, int contextSize) {
+        List<String> ret = new ArrayList<String>();
+        ret.add("--- " + original);
+        ret.add("+++ " + revised);
+        
+        // Hmm, I thought the Deltas were sorted already... turns out they're not.
+        List<Delta> patchDeltas = new ArrayList<Delta>( patch.getDeltas() );
+        Collections.sort( patchDeltas, new Comparator<Delta>() {
+        	public int compare( Delta a, Delta b ) {
+        		return new Integer(a.getOriginal().getPosition()).compareTo( b.getOriginal().getPosition() );
+        	}
+        });
+        
+        // code outside the if block also works for single-delta issues.
+        List<Delta> deltas = new ArrayList<Delta>(); // current list of Delta's to process
+        Delta delta = patchDeltas.get(0);
+        deltas.add(delta); // add the first Delta to the current set
+        // if there's more than 1 Delta, we may need to output them together
+        if (patchDeltas.size() > 1) {
+            for (int i = 1; i < patchDeltas.size(); i++) {
+                int position = delta.getOriginal().getPosition(); // store the current position of
+                                                                   // the first Delta
+                
+                // Check if the next Delta is too close to the current position.
+                // And if it is, add it to the current set
+                Delta nextDelta = patchDeltas.get(i); 
+                if ((position + delta.getOriginal().getSize() + contextSize) >= 
+                    (nextDelta.getOriginal().getPosition() - contextSize)) {
+                    deltas.add(nextDelta); 
+                } else {
+                    // if it isn't, output the current set, 
+                    // then create a new set and add the current Delta to it.
+                    List<String> curBlock = processDeltas(originalLines, deltas, contextSize);
+                    ret.addAll(curBlock);
+                    deltas.clear(); 
+                    deltas.add(nextDelta);
+                }
+                delta = nextDelta;
+            }
+            
+        }
+        // don't forget to process the last set of Deltas
+        List<String> curBlock = processDeltas(originalLines, deltas, contextSize);
+        ret.addAll(curBlock);
+        
+        return ret;
+    }
+    
+    /**
+      * processDeltas takes a list of Deltas and outputs them together in a single block of Unified-Diff-format text.
+     * @author Bill James (tankerbay@gmail.com)
+     * 
+      * @param origLines - the lines of the original file
+      * @param deltas    - the Deltas to be output as a single block
+      * @param contextSize - the number of lines of context to place around block
+      * @return
+      */
+    private static List<String> processDeltas(List<String> origLines, List<Delta> deltas,
+            int contextSize) {
+        List<String> buffer = new ArrayList<String>();
+        int origTotal = 0; // counter for total lines output from Original
+        int revTotal = 0;  // counter for total lines output from Original
+        int line;
+        
+        Delta curDelta = deltas.get(0);
+        
+        // NOTE: +1 to overcome the 0-offset Position
+        int origStart = curDelta.getOriginal().getPosition() + 1 - contextSize;
+        if (origStart < 1) {
+            origStart = 1;
+        }
+        
+        int revStart = curDelta.getRevised().getPosition() + 1 - contextSize;
+        if (revStart < 1) {
+            revStart = 1;
+        }
+        
+        // find the start of the wrapper context code
+        int contextStart = curDelta.getOriginal().getPosition() - contextSize;
+        if (contextStart < 0) {
+            contextStart = 0; // clamp to the start of the file
+        }
+        
+        // output the context before the first Delta
+        for (line = contextStart; line < curDelta.getOriginal().getPosition(); line++) { // 
+            buffer.add(" " + origLines.get(line));
+            origTotal++;
+            revTotal++;
+        }
+        
+        // output the first Delta
+        buffer.addAll(getDeltaText(curDelta)); 
+        origTotal += curDelta.getOriginal().getLines().size();
+        revTotal += curDelta.getRevised().getLines().size();
+        
+        int deltaIndex = 1;
+        while (deltaIndex < deltas.size()) { // for each of the other Deltas
+            Delta nextDelta = deltas.get(deltaIndex);
+            int intermediateStart = curDelta.getOriginal().getPosition()
+                    + curDelta.getOriginal().getLines().size();
+            for (line = intermediateStart; line < nextDelta.getOriginal().getPosition(); line++) {
+                // output the code between the last Delta and this one
+                buffer.add(" " + origLines.get(line));
+                origTotal++;
+                revTotal++;
+            }
+            buffer.addAll(getDeltaText(nextDelta)); // output the Delta
+            origTotal += nextDelta.getOriginal().getLines().size();
+            revTotal += nextDelta.getRevised().getLines().size();
+            curDelta = nextDelta;
+            deltaIndex++;
+        }
+        
+        // Now output the post-Delta context code, clamping the end of the file
+        contextStart = curDelta.getOriginal().getPosition()
+                + curDelta.getOriginal().getLines().size();
+        for (line = contextStart; (line < (contextStart + contextSize))
+                && (line < origLines.size()); line++) {
+            buffer.add(" " + origLines.get(line));
+            origTotal++;
+            revTotal++;
+        }
+        
+        // Create and insert the block header, conforming to the Unified Diff standard
+        StringBuffer header = new StringBuffer();
+        header.append("@@ -");
+        header.append(origStart);
+        header.append(",");
+        header.append(origTotal);
+        header.append(" +");
+        header.append(revStart);
+        header.append(",");
+        header.append(revTotal);
+        header.append(" @@");
+        buffer.add(0, header.toString());
+        
+        return buffer;
+    }
+    
+    /**
+     * getDeltaText returns the lines to be added to the Unified Diff text from the Delta parameter
+     * @author Bill James (tankerbay@gmail.com)
+     * 
+     * @param delta - the Delta to output
+     * @return list of String lines of code.
+     */
+    private static List<String> getDeltaText(Delta delta) {
+        List<String> buffer = new ArrayList<String>();
+        for (Object line : delta.getOriginal().getLines()) {
+            buffer.add("-" + line);
+        }
+        for (Object line : delta.getRevised().getLines()) {
+            buffer.add("+" + line);
+        }
+        return buffer;
+    }
+    
 }
diff --git a/src/difflib/InsertDelta.java b/src/difflib/InsertDelta.java
index 4785144..ffc72d3 100644
--- a/src/difflib/InsertDelta.java
+++ b/src/difflib/InsertDelta.java
@@ -15,7 +15,7 @@
 
     You should have received a copy of the GNU General Public License
     along with Java Diff Utills Library.  If not, see <http://www.gnu.org/licenses/>.
-*/
+ */
 package difflib;
 
 import java.util.List;
@@ -26,52 +26,52 @@
  * @author <a href="dm.naumenko@gmail.com">Dmitry Naumenko</a>
  */
 public class InsertDelta extends Delta {
-
-	/**
-	 * {@inheritDoc}
-	 */
-	public InsertDelta(Chunk original, Chunk revised) {
-		super(original, revised);
-	}
-
-	/**
-	 * {@inheritDoc}
-	 * @throws PatchFailedException 
-	 */
-	@Override
-	public void applyTo(List<Object> target) throws PatchFailedException {
-		verify(target);
-		int position = this.getOriginal().getPosition(); 
-		List<?> lines = this.getRevised().getLines();
-		for (int i = 0; i < lines.size(); i++) {
-			target.add(position + i, lines.get(i));
-		}
-	}
-
-	/**
-	 * {@inheritDoc}
-	 */
-	@Override
-	public void restore(List<Object> target) {
-		int position = getRevised().getPosition();
-		int size = getRevised().getSize();
-		for (int i = 0; i < size; i++) {
-			target.remove(position);
-		}
-	}
-
-	@Override
-	public void verify(List<?> target) throws PatchFailedException {
-		if (getOriginal().getPosition() > target.size()) {
-            throw new PatchFailedException("Incorrect patch for delta: " +
-            		"delta original position > target size");
+    
+    /**
+     * {@inheritDoc}
+     */
+    public InsertDelta(Chunk original, Chunk revised) {
+        super(original, revised);
+    }
+    
+    /**
+     * {@inheritDoc}
+     * @throws PatchFailedException 
+     */
+    @Override
+    public void applyTo(List<Object> target) throws PatchFailedException {
+        verify(target);
+        int position = this.getOriginal().getPosition();
+        List<?> lines = this.getRevised().getLines();
+        for (int i = 0; i < lines.size(); i++) {
+            target.add(position + i, lines.get(i));
         }
-		
-	}
-
-	@Override
-	public String toString() {
-		return "[InsertDelta, position: " + getOriginal().getPosition() + ", lines: " + 
-			getRevised().getLines() + "]"; 
-	}
+    }
+    
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void restore(List<Object> target) {
+        int position = getRevised().getPosition();
+        int size = getRevised().getSize();
+        for (int i = 0; i < size; i++) {
+            target.remove(position);
+        }
+    }
+    
+    @Override
+    public void verify(List<?> target) throws PatchFailedException {
+        if (getOriginal().getPosition() > target.size()) {
+            throw new PatchFailedException("Incorrect patch for delta: "
+                    + "delta original position > target size");
+        }
+        
+    }
+    
+    @Override
+    public String toString() {
+        return "[InsertDelta, position: " + getOriginal().getPosition() + ", lines: "
+                + getRevised().getLines() + "]";
+    }
 }
diff --git a/src/difflib/Patch.java b/src/difflib/Patch.java
index d24ae00..b46fd37 100644
--- a/src/difflib/Patch.java
+++ b/src/difflib/Patch.java
@@ -15,7 +15,7 @@
 
     You should have received a copy of the GNU General Public License
     along with Java Diff Utills Library.  If not, see <http://www.gnu.org/licenses/>.
-*/
+ */
 package difflib;
 
 import java.util.*;
@@ -26,86 +26,85 @@
  * @author <a href="dm.naumenko@gmail.com">Dmitry Naumenko</a>
  */
 public class Patch {
-	private List<Delta> deltas = new LinkedList<Delta>();
-	private boolean isSorted = false;
-	
-	/**
-	 * Apply this patch to the given target
-	 * @param target
-	 * @return the patched text
-	 * @throws PatchFailedException if can't apply patch
-	 */
-	public List<?> applyTo(List<?> target) throws PatchFailedException {
-		List<Object> result = new LinkedList<Object>(target);
-		ListIterator<Delta> it = getDeltas().listIterator(deltas.size());
+    private List<Delta> deltas = new LinkedList<Delta>();
+    private boolean isSorted = false;
+    
+    /**
+     * Apply this patch to the given target
+     * @param target
+     * @return the patched text
+     * @throws PatchFailedException if can't apply patch
+     */
+    public List<?> applyTo(List<?> target) throws PatchFailedException {
+        List<Object> result = new LinkedList<Object>(target);
+        ListIterator<Delta> it = getDeltas().listIterator(deltas.size());
         while (it.hasPrevious()) {
             Delta delta = (Delta) it.previous();
             delta.applyTo(result);
         }
-		return result;
-	}
-	
-	/**
-	 * Restore the text to original. Opposite to applyTo() method.
-	 * @param target the given target
-	 * @return the restored text
-	 */
-	public List<?> restore(List<?> target) {
-		List<Object> result = new LinkedList<Object>(target);
-		ListIterator<Delta> it = getDeltas().listIterator(deltas.size());
+        return result;
+    }
+    
+    /**
+     * Restore the text to original. Opposite to applyTo() method.
+     * @param target the given target
+     * @return the restored text
+     */
+    public List<?> restore(List<?> target) {
+        List<Object> result = new LinkedList<Object>(target);
+        ListIterator<Delta> it = getDeltas().listIterator(deltas.size());
         while (it.hasPrevious()) {
             Delta delta = (Delta) it.previous();
             delta.restore(result);
         }
-		return result;
-	}	
-	
-	/**
-	 * Add the given delta to this patch
-	 * @param delta the given delta
-	 */
-	public void addDelta(Delta delta) {
-		deltas.add(delta);
-		isSorted = false;
-	}
-	
-	/**
-	 * @param deltas the deltas to set
-	 */
-	public void setDeltas(List<Delta> deltas) {
-		this.deltas = deltas;
-		isSorted = false;
-	}
-
-	/**
-	 * Get the list of computed deltas
-	 * @return the deltas
-	 */
-	public List<Delta> getDeltas() {
-		if (!this.isSorted) {
-			Collections.sort(deltas, new Comparator<Delta>() {
-				public int compare(Delta d1, Delta d2) {
-					if (d1.getOriginal().getPosition() > d2.getOriginal().getPosition()) {
-						return 1;
-					} else if (d1.getOriginal().getPosition() > d2.getOriginal().getPosition()) {
-						return -1;
-					} else {
-						return 0;
-					}
-				}
-			}
-			);
-			isSorted = true;
-		}
-		return deltas;
-	}
-	
-	/**
-	 * Get the specific delta from patch deltas
-	 * @param index the index of delta
-	 * @return the needed delta
-	 */
-	public Delta getDelta(int index) {
-		return deltas.get(index);
-	}
+        return result;
+    }
+    
+    /**
+     * Add the given delta to this patch
+     * @param delta the given delta
+     */
+    public void addDelta(Delta delta) {
+        deltas.add(delta);
+        isSorted = false;
+    }
+    
+    /**
+     * @param deltas the deltas to set
+     */
+    public void setDeltas(List<Delta> deltas) {
+        this.deltas = deltas;
+        isSorted = false;
+    }
+    
+    /**
+     * Get the list of computed deltas
+     * @return the deltas
+     */
+    public List<Delta> getDeltas() {
+        if (!this.isSorted) {
+            Collections.sort(deltas, new Comparator<Delta>() {
+                public int compare(Delta d1, Delta d2) {
+                    if (d1.getOriginal().getPosition() > d2.getOriginal().getPosition()) {
+                        return 1;
+                    } else if (d1.getOriginal().getPosition() > d2.getOriginal().getPosition()) {
+                        return -1;
+                    } else {
+                        return 0;
+                    }
+                }
+            });
+            isSorted = true;
+        }
+        return deltas;
+    }
+    
+    /**
+     * Get the specific delta from patch deltas
+     * @param index the index of delta
+     * @return the needed delta
+     */
+    public Delta getDelta(int index) {
+        return deltas.get(index);
+    }
 }
diff --git a/src/difflib/PatchFailedException.java b/src/difflib/PatchFailedException.java
index c30fc0f..6678f00 100644
--- a/src/difflib/PatchFailedException.java
+++ b/src/difflib/PatchFailedException.java
@@ -15,7 +15,7 @@
 
     You should have received a copy of the GNU General Public License
     along with Java Diff Utills Library.  If not, see <http://www.gnu.org/licenses/>.
-*/
+ */
 package difflib;
 
 /**
@@ -24,12 +24,12 @@
  * @author <a href="mailto:juanco@suigeneris.org">Juanco Anez</a>
  */
 public class PatchFailedException extends DiffException {
-
-	private static final long serialVersionUID = 1L;
-
-	public PatchFailedException() {
+    
+    private static final long serialVersionUID = 1L;
+    
+    public PatchFailedException() {
     }
-
+    
     public PatchFailedException(String msg) {
         super(msg);
     }
diff --git a/src/difflib/StringUtills.java b/src/difflib/StringUtills.java
index 312cd28..9e35e44 100644
--- a/src/difflib/StringUtills.java
+++ b/src/difflib/StringUtills.java
@@ -5,64 +5,64 @@
 import java.util.List;
 
 public class StringUtills {
-	
-	public static <T> String join(final Iterable<T> objs, final String delimiter) {
-	    Iterator<T> iter = objs.iterator();
-	    if (!iter.hasNext()) {
-	        return "";
-	    }
-	    StringBuffer buffer = new StringBuffer(String.valueOf(iter.next()));
-	    while (iter.hasNext()) {
-	        buffer.append(delimiter).append(String.valueOf(iter.next()));
-	    }
-	    return buffer.toString();
-	}
-	
-	public static String expandTabs(String str) {
-		return str.replace("\t", "    ");
-	}
-	
-	public static String htmlEntites(String str) {
-		return str.replace("<", "&lt;").replace(">", "&gt;");
-	}
-	
-	public static String normalize(String str) {
-		return expandTabs(htmlEntites(str));
-	}
-	
-	public static List<String> normalize(List<String> list) {
-		List<String> result = new LinkedList<String>();
-		for (String line: list) {
-			result.add(normalize(line));
-		}
-		return result;
-	}
-
-	public static List<String> wrapText(List<String> list, int columnWidth) {
-		List<String> result = new LinkedList<String>();
-		for (String line: list) {
-			result.add(wrapText(line, columnWidth));
-		}
-		return result;
-	}
-	
-	/**
-	 * Wrap the text with the given column width 
-	 * @param line the text
-	 * @param columnWidth the given column
-	 * @return the wrapped text
-	 */
-	public static String wrapText(String line, int columnWidth) {
-		int lenght = line.length();
-		int delimiter = "<br>".length();
-		int widthIndex = columnWidth; 
-		
-		for (int count = 0; lenght > widthIndex; count++) {
-			line = line.subSequence(0, widthIndex + delimiter * count) + "<br>"
-				 + line.substring(widthIndex + delimiter * count);
-			widthIndex += columnWidth;
-		}
-		
-		return line;
-	}
+    
+    public static <T> String join(final Iterable<T> objs, final String delimiter) {
+        Iterator<T> iter = objs.iterator();
+        if (!iter.hasNext()) {
+            return "";
+        }
+        StringBuffer buffer = new StringBuffer(String.valueOf(iter.next()));
+        while (iter.hasNext()) {
+            buffer.append(delimiter).append(String.valueOf(iter.next()));
+        }
+        return buffer.toString();
+    }
+    
+    public static String expandTabs(String str) {
+        return str.replace("\t", "    ");
+    }
+    
+    public static String htmlEntites(String str) {
+        return str.replace("<", "&lt;").replace(">", "&gt;");
+    }
+    
+    public static String normalize(String str) {
+        return expandTabs(htmlEntites(str));
+    }
+    
+    public static List<String> normalize(List<String> list) {
+        List<String> result = new LinkedList<String>();
+        for (String line : list) {
+            result.add(normalize(line));
+        }
+        return result;
+    }
+    
+    public static List<String> wrapText(List<String> list, int columnWidth) {
+        List<String> result = new LinkedList<String>();
+        for (String line : list) {
+            result.add(wrapText(line, columnWidth));
+        }
+        return result;
+    }
+    
+    /**
+     * Wrap the text with the given column width 
+     * @param line the text
+     * @param columnWidth the given column
+     * @return the wrapped text
+     */
+    public static String wrapText(String line, int columnWidth) {
+        int lenght = line.length();
+        int delimiter = "<br>".length();
+        int widthIndex = columnWidth;
+        
+        for (int count = 0; lenght > widthIndex; count++) {
+            line = line.subSequence(0, widthIndex + delimiter * count) + "<br>"
+                    + line.substring(widthIndex + delimiter * count);
+            widthIndex += columnWidth;
+        }
+        
+        return line;
+    }
 }
diff --git a/src/difflib/myers/DiffException.java b/src/difflib/myers/DiffException.java
index 7c78adf..d3802ff 100644
--- a/src/difflib/myers/DiffException.java
+++ b/src/difflib/myers/DiffException.java
@@ -64,18 +64,14 @@
  *
  * @author <a href="mailto:juanco@suigeneris.org">Juanco Anez</a>
  */
-public class DiffException extends Exception
-{
-
-	private static final long serialVersionUID = 1L;
-
-	public DiffException()
-    {
+public class DiffException extends Exception {
+    
+    private static final long serialVersionUID = 1L;
+    
+    public DiffException() {
     }
-
-    public DiffException(String msg)
-    {
+    
+    public DiffException(String msg) {
         super(msg);
     }
 }
-
diff --git a/src/difflib/myers/DiffNode.java b/src/difflib/myers/DiffNode.java
index 92c3330..a2fb071 100644
--- a/src/difflib/myers/DiffNode.java
+++ b/src/difflib/myers/DiffNode.java
@@ -25,9 +25,7 @@
  * @author <a href="mailto:juanco@suigeneris.org">Juanco Anez</a>
  *
  */
-public final class DiffNode
-    extends PathNode
-{
+public final class DiffNode extends PathNode {
     /**
      * Constructs a DiffNode.
      * <p>
@@ -40,18 +38,16 @@ public final class DiffNode
      * @param the position in the revised sequence
      * @param prev the previous node in the path.
      */
-    public DiffNode(int i, int j, PathNode prev)
-    {
-        super(i, j, (prev == null ? null : prev.previousSnake()) );
+    public DiffNode(int i, int j, PathNode prev) {
+        super(i, j, (prev == null ? null : prev.previousSnake()));
     }
-
+    
     /**
      * {@inheritDoc}
      * @return false, always
      */
-    public boolean isSnake()
-    {
+    public boolean isSnake() {
         return false;
     }
-
+    
 }
\ No newline at end of file
diff --git a/src/difflib/myers/DifferentiationFailedException.java b/src/difflib/myers/DifferentiationFailedException.java
index 131a075..a1cdc16 100644
--- a/src/difflib/myers/DifferentiationFailedException.java
+++ b/src/difflib/myers/DifferentiationFailedException.java
@@ -67,17 +67,13 @@
  * @see Diff
  * @see DiffAlgorithm
  */
-public class DifferentiationFailedException extends DiffException
-{
-	private static final long serialVersionUID = 1L;
-
-	public DifferentiationFailedException()
-    {
+public class DifferentiationFailedException extends DiffException {
+    private static final long serialVersionUID = 1L;
+    
+    public DifferentiationFailedException() {
     }
-
-    public DifferentiationFailedException(String msg)
-    {
+    
+    public DifferentiationFailedException(String msg) {
         super(msg);
     }
 }
-
diff --git a/src/difflib/myers/MyersDiff.java b/src/difflib/myers/MyersDiff.java
index 4130814..31605ed 100644
--- a/src/difflib/myers/MyersDiff.java
+++ b/src/difflib/myers/MyersDiff.java
@@ -57,10 +57,16 @@
 
 package difflib.myers;
 
-import java.util.Arrays;
+import java.lang.reflect.Array;
 import java.util.List;
 
-import difflib.*;
+import difflib.ChangeDelta;
+import difflib.Chunk;
+import difflib.DeleteDelta;
+import difflib.Delta;
+import difflib.DiffAlgorithm;
+import difflib.InsertDelta;
+import difflib.Patch;
 
 /**
  * A clean-room implementation of <a href="http://www.cs.arizona.edu/people/gene/">
@@ -71,25 +77,22 @@
  *
  * @author <a href="mailto:juanco@suigeneris.org">Juanco Anez</a>
  */
-public class MyersDiff
-    implements DiffAlgorithm
-{
+public class MyersDiff implements DiffAlgorithm {
     /**
      * Constructs an instance of the Myers differencing algorithm.
      */
-    public MyersDiff()
-    {
+    public MyersDiff() {
     }
-
+    
     /**
      * {@inheritDoc}
      * 
      * Return empty diff if get the error while procession the difference.
      */
-	@Override
-	public Patch diff(List<?> original, List<?> revised) {
-		return diff(original.toArray(), revised.toArray());
-	}
+    @Override
+    public Patch diff(List<?> original, List<?> revised) {
+        return diff(original.toArray(), revised.toArray());
+    }
     
     /**
      * {@inheritDoc}
@@ -97,18 +100,17 @@ public Patch diff(List<?> original, List<?> revised) {
      * Return empty diff if get the error while procession the difference.
      */
     @Override
-    public Patch diff(Object[] orig, Object[] rev)
-    {
+    public Patch diff(Object[] orig, Object[] rev) {
         PathNode path;
-		try {
-			path = buildPath(orig, rev);
-			return buildRevision(path, orig, rev);
-		} catch (DifferentiationFailedException e) {
-			e.printStackTrace();
-		}
+        try {
+            path = buildPath(orig, rev);
+            return buildRevision(path, orig, rev);
+        } catch (DifferentiationFailedException e) {
+            e.printStackTrace();
+        }
         return new Patch();
     }
-
+    
     /**
      * Computes the minimum diffpath that expresses de differences
      * between the original and revised sequences, according
@@ -120,76 +122,67 @@ public Patch diff(Object[] orig, Object[] rev)
      * @throws DifferentiationFailedException if a diff path could not be found.
      */
     public static PathNode buildPath(Object[] orig, Object[] rev)
-        throws DifferentiationFailedException
-    {
+            throws DifferentiationFailedException {
         if (orig == null)
             throw new IllegalArgumentException("original sequence is null");
         if (rev == null)
             throw new IllegalArgumentException("revised sequence is null");
-
+        
         // these are local constants
         final int N = orig.length;
         final int M = rev.length;
-
+        
         final int MAX = N + M + 1;
         final int size = 1 + 2 * MAX;
         final int middle = (size + 1) / 2;
         final PathNode diagonal[] = new PathNode[size];
-
+        
         diagonal[middle + 1] = new Snake(0, -1, null);
-        for (int d = 0; d < MAX; d++)
-        {
-            for (int k = -d; k <= d; k += 2)
-            {
+        for (int d = 0; d < MAX; d++) {
+            for (int k = -d; k <= d; k += 2) {
                 final int kmiddle = middle + k;
                 final int kplus = kmiddle + 1;
                 final int kminus = kmiddle - 1;
                 PathNode prev = null;
-
+                
                 int i;
-                if ( (k == -d) ||
-                    (k != d && diagonal[kminus].i < diagonal[kplus].i))
-                {
+                if ((k == -d) || (k != d && diagonal[kminus].i < diagonal[kplus].i)) {
                     i = diagonal[kplus].i;
                     prev = diagonal[kplus];
-                }
-                else
-                {
+                } else {
                     i = diagonal[kminus].i + 1;
                     prev = diagonal[kminus];
                 }
-
+                
                 diagonal[kminus] = null; // no longer used
-
+                
                 int j = i - k;
-
+                
                 PathNode node = new DiffNode(i, j, prev);
-
+                
                 // orig and rev are zero-based
                 // but the algorithm is one-based
                 // that's why there's no +1 when indexing the sequences
-                while (i < N && j < M && orig[i].equals(rev[j]))
-                {
+                while (i < N && j < M && orig[i].equals(rev[j])) {
                     i++;
                     j++;
                 }
                 if (i > node.i)
                     node = new Snake(i, j, node);
-
+                
                 diagonal[kmiddle] = node;
-
-                if (i >= N && j >= M)
-                {
+                
+                if (i >= N && j >= M) {
                     return diagonal[kmiddle];
                 }
             }
-            diagonal[middle+d-1] = null;
-
+            diagonal[middle + d - 1] = null;
+            
         }
         // According to Myers, this cannot happen
         throw new DifferentiationFailedException("could not find a diff path");
     }
-
+    
     /**
      * Constructs a {@link Revision} from a difference path.
      *
@@ -200,46 +193,67 @@ public static PathNode buildPath(Object[] orig, Object[] rev)
      * @throws DifferentiationFailedException if a {@link Revision} could
      *         not be built from the given path.
      */
-    public static Patch buildRevision(PathNode path, Object[] orig, Object[] rev)
-    {
+    public static Patch buildRevision(PathNode path, Object[] orig, Object[] rev) {
         if (path == null)
             throw new IllegalArgumentException("path is null");
         if (orig == null)
             throw new IllegalArgumentException("original sequence is null");
         if (rev == null)
             throw new IllegalArgumentException("revised sequence is null");
-
+        
         Patch patch = new Patch();
         if (path.isSnake())
             path = path.prev;
-        while (path != null && path.prev != null && path.prev.j >= 0)
-        {
-            if(path.isSnake()) 
-               throw new IllegalStateException("bad diffpath: found snake when looking for diff");
+        while (path != null && path.prev != null && path.prev.j >= 0) {
+            if (path.isSnake())
+                throw new IllegalStateException("bad diffpath: found snake when looking for diff");
             int i = path.i;
             int j = path.j;
-
+            
             path = path.prev;
             int ianchor = path.i;
             int janchor = path.j;
             
-            Chunk original = new Chunk(ianchor, i - ianchor, Arrays.copyOfRange(orig, ianchor, i));
-            Chunk revised = new Chunk(janchor, j - janchor, Arrays.copyOfRange(rev, janchor, j));
+            Chunk original = new Chunk(ianchor, i - ianchor, copyOfRange(orig, ianchor, i));
+            Chunk revised = new Chunk(janchor, j - janchor, copyOfRange(rev, janchor, j));
             Delta delta = null;
             if (original.getSize() == 0 && revised.getSize() != 0) {
-            	delta = new InsertDelta(original, revised);
+                delta = new InsertDelta(original, revised);
             } else if (original.getSize() > 0 && revised.getSize() == 0) {
-            	delta = new DeleteDelta(original, revised);
+                delta = new DeleteDelta(original, revised);
             } else {
-            	delta = new ChangeDelta(original, revised);
+                delta = new ChangeDelta(original, revised);
             }
             
-                                         
             patch.addDelta(delta);
             if (path.isSnake())
                 path = path.prev;
         }
         return patch;
     }
-
+    
+    /**
+     * Copied here from JDK 1.6
+    */
+    
+    @SuppressWarnings("unchecked")
+    public static <T> T[] copyOfRange(T[] original, int from, int to) {
+        return copyOfRange(original, from, to, (Class<T[]>) original.getClass());
+    }
+    
+    /**
+     * Copied here from JDK 1.6
+     */
+    @SuppressWarnings("unchecked")
+    public static <T, U> T[] copyOfRange(U[] original, int from, int to,
+            Class<? extends T[]> newType) {
+        int newLength = to - from;
+        if (newLength < 0)
+            throw new IllegalArgumentException(from + " > " + to);
+        T[] copy = ((Object) newType == (Object) Object[].class) ? (T[]) new Object[newLength]
+                : (T[]) Array.newInstance(newType.getComponentType(), newLength);
+        System.arraycopy(original, from, copy, 0, Math.min(original.length - from, newLength));
+        return copy;
+    }
+    
 }
diff --git a/src/difflib/myers/PathNode.java b/src/difflib/myers/PathNode.java
index 4e98082..4ead5f2 100644
--- a/src/difflib/myers/PathNode.java
+++ b/src/difflib/myers/PathNode.java
@@ -67,34 +67,32 @@
  * @see Snake
  *
  */
-public abstract class PathNode
-{
+public abstract class PathNode {
     /** Position in the original sequence. */
     public final int i;
     /** Position in the revised sequence. */
     public final int j;
     /** The previous node in the path. */
     public final PathNode prev;
-
+    
     /**
      * Concatenates a new path node with an existing diffpath.
      * @param i The position in the original sequence for the new node.
      * @param j The position in the revised sequence for the new node.
      * @param prev The previous node in the path.
      */
-    public PathNode(int i, int j, PathNode prev)
-    {
+    public PathNode(int i, int j, PathNode prev) {
         this.i = i;
         this.j = j;
         this.prev = prev;
     }
-
+    
     /**
      * Is this node a {@link Snake Snake node}?
      * @return true if this is a {@link Snake Snake node}
      */
     public abstract boolean isSnake();
-
+    
     /**
      * Is this a bootstrap node?
      * <p>
@@ -102,11 +100,10 @@ public PathNode(int i, int j, PathNode prev)
      * less than zero.
      * @return tru if this is a bootstrap node.
      */
-    public boolean isBootstrap()
-    {
+    public boolean isBootstrap() {
         return i < 0 || j < 0;
     }
-
+    
     /**
      * Skips sequences of {@link DiffNode DiffNodes} until a
      * {@link Snake} or bootstrap node is found, or the end
@@ -115,24 +112,21 @@ public boolean isBootstrap()
      * <code>null</code>
      * if none found.
      */
-    public final PathNode previousSnake()
-    {
+    public final PathNode previousSnake() {
         if (isBootstrap())
             return null;
         if (!isSnake() && prev != null)
             return prev.previousSnake();
         return this;
     }
-
+    
     /**
      * {@inheritDoc}
      */
-    public String toString()
-    {
+    public String toString() {
         StringBuffer buf = new StringBuffer("[");
         PathNode node = this;
-        while (node != null)
-        {
+        while (node != null) {
             buf.append("(");
             buf.append(Integer.toString(node.i));
             buf.append(",");
diff --git a/src/difflib/myers/Snake.java b/src/difflib/myers/Snake.java
index b19b17e..452829b 100644
--- a/src/difflib/myers/Snake.java
+++ b/src/difflib/myers/Snake.java
@@ -70,9 +70,7 @@
  * @author <a href="mailto:juanco@suigeneris.org">Juanco Anez</a>
  *
  */
-public final class Snake
-    extends PathNode
-{
+public final class Snake extends PathNode {
     /**
      * Constructs a snake node.
      *
@@ -80,18 +78,16 @@ public final class Snake
      * @param the position in the revised sequence
      * @param prev the previous node in the path.
      */
-    public Snake(int i, int j, PathNode prev)
-    {
+    public Snake(int i, int j, PathNode prev) {
         super(i, j, prev);
     }
-
+    
     /**
      * {@inheritDoc}
      * @return true always
      */
-    public boolean isSnake()
-    {
+    public boolean isSnake() {
         return true;
     }
-
+    
 }
\ No newline at end of file
diff --git a/test/mocks/one_delta_test_original.txt b/test/mocks/one_delta_test_original.txt
new file mode 100644
index 0000000..5d54330
--- /dev/null
+++ b/test/mocks/one_delta_test_original.txt
@@ -0,0 +1,54 @@
+<p>Esta &eacute; uma obra Online.</p>
+<p>&nbsp;</p>
+<p><strong>Este texto &eacute; negrito</strong></p>
+<p><em>Este texto &eacute; it&aacute;lico</em></p>
+<p><span style="text-decoration:underline;">Este texto est&aacute; sublinhado</span></p>
+<p><span style="text-decoration: line-through;">Este texto est&aacute; riscado</span></p>
+<p style="text-align: center;">Este texto est&aacute; centralizado</p>
+<p style="text-align: right;">Este texto est&aacute; alinhado a direita</p>
+<ol>
+<li>Este texto est&aacute; em uma lista num&eacute;rica<ol>
+<li>Este texto est&aacute; identado</li>
+</ol></li>
+</ol>
+<p><a title="uol" href="http://www.uol.com.br" target="_blank">Este
+aqui &eacute; um link</a></p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>,
+<p>&nbsp;</p>
+<p>P&aacute;gina 1</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>P&aacute;gina 2</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>&nbsp;</p>
+<p>P&aacute;gina 3</p>
+<p>&nbsp;</p>
\ No newline at end of file
diff --git a/test/mocks/one_delta_test_revised.txt b/test/mocks/one_delta_test_revised.txt
new file mode 100644
index 0000000..9197a73
--- /dev/null
+++ b/test/mocks/one_delta_test_revised.txt
@@ -0,0 +1,11 @@
+<p>Revis&atilde;o 3</p><p>&nbsp;</p><p>Esta &eacute; uma obra
+Online.</p><p>&nbsp;</p><p><strong>Este texto &eacute;
+negrit</strong></p><p>Este texto &eacute; it&aacute;lico/p><p><span
+style="text-decoration: undeline;">Este texto est&aacute;
+sublinhado</span></p><p>Este texto est&aacute; riscado agora n&atilde;o
+est&aacute; mais</p>p style="text-align: left;">Este texto est&aacute;
+centralizado nem este</p><p style="text-align: right;">Este texto
+est&aacute; alinhado a direita</p><ol><li>Este texto est&aacute; em uma
+lista num&eacute;rica</li></ol><p><a title="uol"
+href="http://www.uol.com.br" target="_blank">Este aqui &eacute; um
+link</a></p>
\ No newline at end of file
diff --git a/test/mocks/original.txt b/test/mocks/original.txt
new file mode 100644
index 0000000..479dca0
--- /dev/null
+++ b/test/mocks/original.txt
@@ -0,0 +1,174 @@
+/*
+    Copyright 2009 Dmitry Naumenko (dm.naumenko@gmail.com)
+    
+    This file is part of Java Diff Utills Library.
+
+    Java Diff Utills Library is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Java Diff Utills Library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Java Diff Utills Library.  If not, see <http://www.gnu.org/licenses/>.
+*/
+package difflib;
+
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import difflib.myers.*;
+
+/**
+ * Implements the difference and patching engine
+ * 
+ * @author <a href="dm.naumenko@gmail.com">Dmitry Naumenko</a>
+ * @version 0.4.1
+ */
+public class DiffUtils {
+	private static DiffAlgorithm defaultDiffAlgorithm = new MyersDiff();
+	private static Pattern unifiedDiffChunkRe = 
+		Pattern.compile("@@\\s+-(?:(\\d+)(?:,(\\d+))?)\\s+\\+(?:(\\d+)(?:,(\\d+))?)\\s+@@");
+	
+	/**
+	 * Compute the difference between the original and revised texts with default diff algorithm 
+	 * 
+	 * @param original the original text
+	 * @param revised the revised text
+	 * @return the patch describing the difference between the original and revised texts 
+	 */
+	public static Patch diff(List<?> original, List<?> revised) {
+		return DiffUtils.diff(original, revised, defaultDiffAlgorithm);
+	}
+	
+	/**
+	 * Compute the difference between the original and revised texts with given diff algorithm 
+	 * 
+	 * @param original the original text
+	 * @param revised the revised text
+	 * @param algorithm the given algorithm
+	 * @return the patch describing the difference between the original and revised texts
+	 */
+	public static Patch diff(List<?> original, List<?> revised, DiffAlgorithm algorithm) {
+		return algorithm.diff(original, revised);
+	}
+	
+	/**
+	 * Patch the original text with given patch
+	 * 
+	 * @param original the original text
+	 * @param patch the given patch
+	 * @return the revised text
+	 * @throws PatchFailedException if can't apply patch
+	 */
+	public static List<?> patch(List<?> original, Patch patch) throws PatchFailedException {
+		return patch.applyTo(original);
+	}
+	
+	/**
+	 * Unpatch the revised text for a given patch
+	 * 
+	 * @param revised the revised text
+	 * @param patch the given patch
+	 * @return the original text
+	 */
+	public static List<?> unpatch(List<?> revised, Patch patch) {
+		return patch.restore(revised);
+	}
+	
+	/**
+	 * Parse the given text in unified format and creates the list of deltas for it.
+	 * 
+	 * @param diff the text in unified format 
+	 * @return the patch with deltas.
+	 */
+	public static Patch parseUnifiedDiff(List<String> diff) {
+		boolean inPrelude = true;
+		List<Object[]> rawChunk = new ArrayList<Object[]>();
+		Patch patch = new Patch();
+		
+		int old_ln = 0, old_n = 0, new_ln = 0, new_n = 0;
+		String tag = "", rest = "";
+		for (String line: diff) {
+			// Skip leading lines until after we've seen one starting with '+++'
+			if (inPrelude) {
+				if (line.startsWith("+++")) {
+					inPrelude = false;
+				}
+				continue;
+			}
+			Matcher m = unifiedDiffChunkRe.matcher(line);
+			if (m.find()) {
+				// Process the lines in the previous chunk
+				if (rawChunk.size() != 0) {
+					List<String> oldChunkLines = new ArrayList<String>();
+					List<String> newChunkLines = new ArrayList<String>();
+					
+					for (Object[] raw_line: rawChunk) {
+						tag = (String)raw_line[0];
+						rest = (String)raw_line[1];
+						if (tag.equals(" ") || tag.equals("-")) {
+							oldChunkLines.add(rest);
+						}
+						if (tag.equals(" ") || tag.equals("+")) {
+							newChunkLines.add(rest);
+						}
+					}
+					patch.addDelta(new ChangeDelta(new Chunk(old_ln - 1, old_n, oldChunkLines),  
+							new Chunk(new_ln - 1, new_n, newChunkLines)));
+					rawChunk.clear();
+				}
+				// Parse the @@ header
+				old_ln = m.group(1) == null ? 1 : Integer.parseInt(m.group(1));
+				old_n  = m.group(2) == null ? 1 : Integer.parseInt(m.group(2));
+				new_ln = m.group(3) == null ? 1 : Integer.parseInt(m.group(3));
+				new_n  = m.group(4) == null ? 1 : Integer.parseInt(m.group(4));
+				old_ln = Integer.parseInt(m.group(1));
+				
+				if (old_ln == 0) {
+					old_ln += 1; 
+				}
+				if (new_ln == 0) {
+					new_ln += 1;
+				}
+			} else {
+				if (line.length() > 0) {
+					tag  = line.substring(0, 1);
+					rest = line.substring(1);
+					if (tag.equals(" ") || tag.equals("+") || tag.equals("-")) {
+						rawChunk.add(new Object[] {tag, rest});
+					}
+				}
+			}
+		}
+		
+		// Process the lines in the last chunk
+		if (rawChunk.size() != 0) {
+			List<String> oldChunkLines = new ArrayList<String>();
+			List<String> newChunkLines = new ArrayList<String>();
+			
+			for (Object[] raw_line: rawChunk) {
+				tag = (String)raw_line[0];
+				rest = (String)raw_line[1];
+				if (tag.equals(" ") || tag.equals("-")) {
+					oldChunkLines.add(rest);
+				} 
+				if (tag.equals(" ") || tag.equals("+")) {
+					newChunkLines.add(rest);
+				}
+			}
+			
+			patch.addDelta(new ChangeDelta(new Chunk(old_ln - 1, old_n, oldChunkLines),  
+					new Chunk(new_ln - 1, new_n, newChunkLines)));
+			rawChunk.clear();
+		}
+		
+		return patch;
+	}
+	
+}
diff --git a/test/mocks/revised.txt b/test/mocks/revised.txt
new file mode 100644
index 0000000..3c19df3
--- /dev/null
+++ b/test/mocks/revised.txt
@@ -0,0 +1,308 @@
+/*
+    Copyright 2009 Dmitry Naumenko (dm.naumenko@gmail.com)
+    
+    This file is part of Java Diff Utils Library.
+
+    Java Diff Utils Library is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Java Diff Utils Library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Java Diff Utils Library.  If not, see <http://www.gnu.org/licenses/>.
+*/
+package difflib;
+
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import difflib.myers.*;
+
+/**
+ * Implements the difference and patching engine
+ * 
+ * @author <a href="dm.naumenko@gmail.com">Dmitry Naumenko</a>
+ * @version 0.4.1
+ */
+public class DiffUtils {
+	private static DiffAlgorithm defaultDiffAlgorithm = new MyersDiff();
+	private static Pattern unifiedDiffChunkRe = 
+		Pattern.compile("@@\\s+-(?:(\\d+)(?:,(\\d+))?)\\s+\\+(?:(\\d+)(?:,(\\d+))?)\\s+@@");
+	
+	/**
+	 * Compute the difference between the original and revised texts with default diff algorithm 
+	 * 
+	 * @param original the original text
+	 * @param revised the revised text
+	 * @return the patch describing the difference between the original and revised texts 
+	 */
+	public static Patch diff(List<?> original, List<?> revised) {
+		return DiffUtils.diff(original, revised, defaultDiffAlgorithm);
+	}
+	
+	/**
+	 * Compute the difference between the original and revised texts with given diff algorithm 
+	 * 
+	 * @param original the original text
+	 * @param revised the revised text
+	 * @param algorithm the given algorithm
+	 * @return the patch describing the difference between the original and revised texts
+	 */
+	public static Patch diff(List<?> original, List<?> revised, DiffAlgorithm algorithm) {
+		return algorithm.diff(original, revised);
+	}
+	
+	/**
+	 * Patch the original text with given patch
+	 * 
+	 * @param original the original text
+	 * @param patch the given patch
+	 * @return the revised text
+	 * @throws PatchFailedException if can't apply patch
+	 */
+	public static List<?> patch(List<?> original, Patch patch) throws PatchFailedException {
+		return patch.applyTo(original);
+	}
+	
+	/**
+	 * Unpatch the revised text for a given patch
+	 * 
+	 * @param revised the revised text
+	 * @param patch the given patch
+	 * @return the original text
+	 */
+	public static List<?> unpatch(List<?> revised, Patch patch) {
+		return patch.restore(revised); // bla-bla-bla
+	}
+	
+	/**
+	 * Parse the given text in unified format and creates the list of deltas for it.
+	 * 
+	 * @param diff the text in unified format 
+	 * @return the patch with deltas.
+	 */
+	public static Patch parseUnifiedDiff(List<String> diff) {
+		boolean inPrelude = true;
+		List<Object[]> rawChunk = new ArrayList<Object[]>();
+		Patch patch = new Patch();
+		
+		int old_ln = 0, old_n = 0, new_ln = 0, new_n = 0;
+		String tag = "", rest = "";
+		for (String line: diff) {
+			// Skip leading lines until after we've seen one starting with '+++'
+			if (inPrelude) {
+				if (line.startsWith("+++")) {
+					inPrelude = false;
+				}
+				continue;
+			}
+			Matcher m = unifiedDiffChunkRe.matcher(line);
+			if (m.find()) {
+				// Process the lines in the previous chunk
+				if (rawChunk.size() != 0) {
+					List<String> oldChunkLines = new ArrayList<String>();
+					List<String> newChunkLines = new ArrayList<String>();
+					
+					for (Object[] raw_line: rawChunk) {
+						tag = (String)raw_line[0];
+						rest = (String)raw_line[1];
+						if (tag.equals(" ") || tag.equals("-")) {
+							oldChunkLines.add(rest);
+						}
+						if (tag.equals(" ") || tag.equals("+")) {
+							newChunkLines.add(rest);
+						}
+					}
+					patch.addDelta(new ChangeDelta(new Chunk(old_ln - 1, old_n, oldChunkLines),  
+							new Chunk(new_ln - 1, new_n, newChunkLines)));
+					rawChunk.clear();
+				}
+				// Parse the @@ header
+				old_ln = m.group(1) == null ? 1 : Integer.parseInt(m.group(1));
+				old_n  = m.group(2) == null ? 1 : Integer.parseInt(m.group(2));
+				new_ln = m.group(3) == null ? 1 : Integer.parseInt(m.group(3));
+				new_n  = m.group(4) == null ? 1 : Integer.parseInt(m.group(4));
+				old_ln = Integer.parseInt(m.group(1));
+				
+				if (old_ln == 0) {
+					old_ln += 1; 
+				}
+				if (new_ln == 0) {
+					new_ln += 1;
+				}
+			} else {
+				if (line.length() > 0) {
+					tag  = line.substring(0, 1);
+					rest = line.substring(1);
+					if (tag.equals(" ") || tag.equals("+") || tag.equals("-")) {
+						rawChunk.add(new Object[] {tag, rest});
+					}
+				}
+			}
+		}
+		
+		// Process the lines in the last chunk
+		if (rawChunk.size() != 0) {
+			List<String> oldChunkLines = new ArrayList<String>();
+			List<String> newChunkLines = new ArrayList<String>();
+			
+			for (Object[] raw_line: rawChunk)
+            {
+				tag = (String)raw_line[0];
+				rest = (String)raw_line[1];
+				if (tag.equals(" ") || tag.equals("-"))
+                {
+					oldChunkLines.add(rest);
+				} 
+				if (tag.equals(" ") || tag.equals("+"))
+                {
+					newChunkLines.add(rest);
+				}
+			}
+			
+			patch.addDelta(new ChangeDelta(new Chunk(old_ln - 1, old_n, oldChunkLines),  
+					new Chunk(new_ln - 1, new_n, newChunkLines)));
+			rawChunk.clear();
+		}
+		
+		return patch;
+	}
+
+	/**
+	 * generateUnifiedDiff takes a Patch and some other arguments, returning the Unified Diff format text representing the Patch.
+	 * @author Bill James (tankerbay@gmail.com)
+	 * 
+	 * @param fname1 - Filename of the original (unrevised file)
+	 * @param fname2 - Filename of the revised file
+	 * @param originalLines - Lines of the original file
+	 * @param patch - Patch created by the diff() function
+	 * @param contextSize - number of lines of context output around each difference in the file.
+	 * @return List of strings representing the Unified Diff representation of the Patch argument.
+	 */
+	public static List<String> generateUnifiedDiff(String fname1, String fname2, List<String> originalLines, Patch patch, int contextSize ) {
+		List<String> ret = new ArrayList<String>();
+		ret.add( "--- " + fname1 );
+		ret.add( "+++ " + fname2 );
+		
+        List<Delta> cur = new ArrayList<Delta>();   // current list of Delta's to process
+        int deltact = patch.getDeltas().size();
+        // if there's more than 1 Delta, we may need to output them together
+        if ( deltact > 1 ) {
+          Delta curDelta = patch.getDelta(0);
+          cur.add( curDelta );   									// add the first Delta to the current set
+          for ( int i = 1; i < deltact; i++ ) {
+        	int curpos = curDelta.getOriginal().getPosition();   		// store the current position of the first Delta  
+            Delta nextDelta = patch.getDelta(i);						// Check if the next Delta is too close to the current position
+            if ( (curpos + curDelta.getOriginal().getSize() + contextSize) >= ( nextDelta.getOriginal().getPosition()-contextSize ) ) {
+              cur.add( nextDelta );  								// if it is, add it to the current set
+            } else {
+              List<String> curBlock = processDeltas( originalLines, cur, contextSize );
+              ret.addAll( curBlock );							// if it isn't, output the current set, then create a new 
+              cur.clear();											// set and add the current Delta to it.
+              cur.add( nextDelta );
+            }
+            curDelta = nextDelta;
+          }
+          List<String> curBlock = processDeltas( originalLines, cur, contextSize );  // don't forget to process the last set of Deltas
+          ret.addAll( curBlock );
+        }
+
+		return ret;
+	}
+
+   /**
+     * processDeltas takes a list of Deltas and outputs them together in a single block of Unified-Diff-format text.
+	 * @author Bill James (tankerbay@gmail.com)
+	 * 
+     * @param origLines - the lines of the original file
+     * @param deltas    - the Deltas to be output as a single block
+     * @param contextSize - the number of lines of context to place around block
+     * @return
+     */
+      private static List<String> processDeltas( List<String> origLines, List<Delta> deltas, int contextSize ) {
+        List<String> buffer = new ArrayList<String>();
+        int origTotal = 0;   // counter for total lines output from Original
+        int revTotal = 0;    // counter for total lines output from Original
+        int line;
+
+        Delta curDelta = deltas.get(0);  // start with the first Delta
+        int origStart = curDelta.getOriginal().getPosition()+1 - contextSize;  	// note the +1 to overcome the 0-offset Position
+        if ( origStart < 1 ) origStart = 1;                                    	// clamp to the start of the file
+        int revStart = curDelta.getRevised().getPosition()+1 - contextSize;    	// note the +1 to overcome the 0-offset Position
+        if ( revStart < 1 ) revStart = 1;										// clamp to the start of the file
+        int contextStart = curDelta.getOriginal().getPosition() - contextSize;	// find the start of the wrapper context code
+        if ( contextStart < 0 ) contextStart = 0;								// clamp to the start of the file
+        for ( line = contextStart; line < curDelta.getOriginal().getPosition(); line++ ) {  // output the context before the first Delta
+          buffer.add( " " + origLines.get( line ) );
+          origTotal++;
+          revTotal++;
+        }
+        buffer.addAll( getDeltaText( curDelta ) );           					// output the first Delta
+        origTotal += curDelta.getOriginal().getLines().size();
+        revTotal += curDelta.getRevised().getLines().size();
+
+        int deltaIndex = 1;
+        while ( deltaIndex < deltas.size() ) { 									// for each of the other Deltas
+           Delta nextDelta = deltas.get( deltaIndex );
+           int intermediateStart = curDelta.getOriginal().getPosition() + curDelta.getOriginal().getLines().size();
+           for ( line = intermediateStart; line < nextDelta.getOriginal().getPosition(); line++ ) {
+              buffer.add( " " + origLines.get( line ) );						// output the code between the last Delta and this one
+              origTotal++;
+              revTotal++;
+           }
+           buffer.addAll( getDeltaText( nextDelta ) );							// output the Delta
+           origTotal += nextDelta.getOriginal().getLines().size();
+           revTotal += nextDelta.getRevised().getLines().size();
+           curDelta = nextDelta;
+           deltaIndex++;														// increment the iterator
+        }
+
+        // Now output the post-Delta context code, clamping the end of the file
+        contextStart = curDelta.getOriginal().getPosition() + curDelta.getOriginal().getLines().size();
+        for ( line = contextStart; ( line < (contextStart + contextSize )) && ( line < origLines.size() ); line++ ) {
+          buffer.add( " " + origLines.get( line ) );
+          origTotal++;
+          revTotal++;
+        }
+
+        // Create and insert the block header, conforming to the Unified Diff standard
+        StringBuffer header = new StringBuffer();
+        header.append( "@@ -" );
+        header.append( origStart );
+        header.append( "," );
+        header.append( origTotal );
+        header.append( " +" );
+        header.append( revStart );
+        header.append( "," );
+        header.append( revTotal );
+        header.append( " @@" );
+        buffer.add( 0, header.toString() );
+
+        return buffer;
+      }
+
+      /**
+       * getDeltaText returns the lines to be added to the Unified Diff text from the Delta parameter
+       * @author Bill James (tankerbay@gmail.com)
+       * 
+       * @param delta - the Delta to output
+       * @return list of String lines of code.
+       */
+      private static List<String> getDeltaText( Delta delta ) {
+        List<String> buffer = new ArrayList<String>();
+        for ( Object line: delta.getOriginal().getLines() ) {
+          buffer.add( "-" + line );
+        }
+        for ( Object line: delta.getRevised().getLines() ) {
+          buffer.add( "+" + line );
+        }
+        return buffer;
+      }
+	
+}
diff --git a/test/testcase/diffutills/DiffTest.java b/test/testcase/diffutills/DiffTest.java
index 4e8450c..8e340de 100644
--- a/test/testcase/diffutills/DiffTest.java
+++ b/test/testcase/diffutills/DiffTest.java
@@ -6,51 +6,63 @@
 import difflib.*;
 
 public class DiffTest extends TestCase {
-	private List<String> changeTest_from = Arrays.asList("aaa", "bbb", "ccc");
-	private List<String> changeTest_to   = Arrays.asList("aaa", "zzz", "ccc");
-	
-	private List<String> deleteTest_from = Arrays.asList("ddd", "fff", "ggg");
-	private List<String> deleteTest_to   = Arrays.asList("ggg");
-	
-	private List<String> insertTest_from = Arrays.asList("hhh");
-	private List<String> insertTest_to   = Arrays.asList("hhh", "jjj", "kkk");
-	
-	@SuppressWarnings("serial")
-	public void testDiff_Insert() {
-		Patch patch = DiffUtils.diff(insertTest_from, insertTest_to);
-		assertNotNull(patch);
-		assertEquals(patch.getDeltas().size(), 1);
-		Delta delta = patch.getDeltas().get(0);
-		assertEquals(InsertDelta.class, delta.getClass());
-		assertEquals(new Chunk(1, 0, new LinkedList<String>()), 
-				delta.getOriginal());
-		assertEquals(new Chunk(1, 2, new LinkedList<String>() {{ add("jjj"); add("kkk"); }}), 
-				delta.getRevised());
-	}
-	
-	@SuppressWarnings("serial")
-	public void testDiff_Delete() {
-		Patch patch = DiffUtils.diff(deleteTest_from, deleteTest_to);
-		assertNotNull(patch);
-		assertEquals(patch.getDeltas().size(), 1);
-		Delta delta = patch.getDeltas().get(0);
-		assertEquals(DeleteDelta.class, delta.getClass());
-		assertEquals(new Chunk(0, 2, new LinkedList<String>() {{ add("ddd"); add("fff"); }}), 
-				delta.getOriginal());
-		assertEquals(new Chunk(0, 0, new LinkedList<String>()), 
-				delta.getRevised());
-	}
-	
-	@SuppressWarnings("serial")
-	public void testDiff_Change() {
-		Patch patch = DiffUtils.diff(changeTest_from, changeTest_to);
-		assertNotNull(patch);
-		assertEquals(patch.getDeltas().size(), 1);
-		Delta delta = patch.getDeltas().get(0);
-		assertEquals(ChangeDelta.class, delta.getClass());
-		assertEquals(new Chunk(1, 1, new LinkedList<String>() {{ add("bbb"); }}), 
-				delta.getOriginal());
-		assertEquals(new Chunk(1, 1, new LinkedList<String>() {{ add("zzz"); }}), 
-				delta.getRevised());
-	}
+    private List<String> changeTest_from = Arrays.asList("aaa", "bbb", "ccc");
+    private List<String> changeTest_to = Arrays.asList("aaa", "zzz", "ccc");
+    
+    private List<String> deleteTest_from = Arrays.asList("ddd", "fff", "ggg");
+    private List<String> deleteTest_to = Arrays.asList("ggg");
+    
+    private List<String> insertTest_from = Arrays.asList("hhh");
+    private List<String> insertTest_to = Arrays.asList("hhh", "jjj", "kkk");
+    
+    @SuppressWarnings("serial")
+    public void testDiff_Insert() {
+        Patch patch = DiffUtils.diff(insertTest_from, insertTest_to);
+        assertNotNull(patch);
+        assertEquals(patch.getDeltas().size(), 1);
+        Delta delta = patch.getDeltas().get(0);
+        assertEquals(InsertDelta.class, delta.getClass());
+        assertEquals(new Chunk(1, 0, new LinkedList<String>()), delta.getOriginal());
+        assertEquals(new Chunk(1, 2, new LinkedList<String>() {
+            {
+                add("jjj");
+                add("kkk");
+            }
+        }), delta.getRevised());
+    }
+    
+    @SuppressWarnings("serial")
+    public void testDiff_Delete() {
+        Patch patch = DiffUtils.diff(deleteTest_from, deleteTest_to);
+        assertNotNull(patch);
+        assertEquals(patch.getDeltas().size(), 1);
+        Delta delta = patch.getDeltas().get(0);
+        assertEquals(DeleteDelta.class, delta.getClass());
+        assertEquals(new Chunk(0, 2, new LinkedList<String>() {
+            {
+                add("ddd");
+                add("fff");
+            }
+        }), delta.getOriginal());
+        assertEquals(new Chunk(0, 0, new LinkedList<String>()), delta.getRevised());
+    }
+    
+    @SuppressWarnings("serial")
+    public void testDiff_Change() {
+        Patch patch = DiffUtils.diff(changeTest_from, changeTest_to);
+        assertNotNull(patch);
+        assertEquals(patch.getDeltas().size(), 1);
+        Delta delta = patch.getDeltas().get(0);
+        assertEquals(ChangeDelta.class, delta.getClass());
+        assertEquals(new Chunk(1, 1, new LinkedList<String>() {
+            {
+                add("bbb");
+            }
+        }), delta.getOriginal());
+        assertEquals(new Chunk(1, 1, new LinkedList<String>() {
+            {
+                add("zzz");
+            }
+        }), delta.getRevised());
+    }
 }
diff --git a/test/testcase/diffutills/GenerateUnifiedDiffTest.java b/test/testcase/diffutills/GenerateUnifiedDiffTest.java
new file mode 100644
index 0000000..8a3e037
--- /dev/null
+++ b/test/testcase/diffutills/GenerateUnifiedDiffTest.java
@@ -0,0 +1,88 @@
+package testcase.diffutills;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+import difflib.DiffUtils;
+import difflib.Patch;
+import difflib.PatchFailedException;
+
+import junit.framework.TestCase;
+
+public class GenerateUnifiedDiffTest extends TestCase {
+    static final String FS = File.separator;
+    static final String originalFilename = "test" + FS + "mocks" + FS + "original.txt";
+    static final String revisedFilename = "test" + FS + "mocks" + FS + "revised.txt";
+    static final String originalFilenameOneDelta = "test" + FS + "mocks" + FS + "one_delta_test_original.txt";
+    static final String revisedFilenameOneDelta = "test" + FS + "mocks" + FS + "one_delta_test_revised.txt";
+    
+    public List<String> fileToLines(String filename) {
+        List<String> lines = new LinkedList<String>();
+        String line = "";
+        try {
+            BufferedReader in = new BufferedReader(new FileReader(filename));
+            while ((line = in.readLine()) != null) {
+                lines.add(line);
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return lines;
+    }
+    
+    /**
+     * Tests the Unified Diff generation by creating a Patch, then
+     * creating the Unified Diff representation, then parsing that
+     * Unified Diff, and applying the patch to the original unrevised
+     * text, then comparing that to the original revised text.
+     *         
+     * @author Bill James (tankerbay@gmail.com)
+     */
+    public void testGenerateUnified() {
+        List<String> origLines = fileToLines(originalFilename);
+        List<String> revLines = fileToLines(revisedFilename);
+        
+        testGenerateUnified(origLines, revLines);
+    }
+    
+    /**
+     * Tests the Unified Diff generation for diff with one delta.
+     */
+    public void testGenerateUnifiedWithOneDelta() {
+        List<String> origLines = fileToLines(originalFilenameOneDelta);
+        List<String> revLines = fileToLines(revisedFilenameOneDelta);
+        
+        testGenerateUnified(origLines, revLines);
+    }
+    
+    private void testGenerateUnified(List<String> origLines, List<String> revLines) {
+        Patch p = DiffUtils.diff(origLines, revLines);
+        List<String> unifiedDiff = DiffUtils.generateUnifiedDiff(
+                originalFilename, revisedFilename, origLines, p, 10);
+        
+        Patch fromUnifiedPatch = DiffUtils.parseUnifiedDiff(unifiedDiff);
+        List<String> patchedLines = new ArrayList<String>();
+        try {
+            patchedLines = (List<String>) fromUnifiedPatch.applyTo(origLines);
+        } catch (PatchFailedException e) {
+            // TODO Auto-generated catch block
+            fail(e.getMessage());
+        }
+        
+        assertTrue(revLines.size() == patchedLines.size());
+        for (int i = 0; i < revLines.size(); i++) {
+            String l1 = revLines.get(i);
+            String l2 = patchedLines.get(i);
+            if (l1.equals(l2) == false) {
+                fail("Line " + (i + 1) + " of the patched file did not match the revised original");
+            }
+        }
+    }
+
+
+}
diff --git a/test/testcase/diffutills/PatchTest.java b/test/testcase/diffutills/PatchTest.java
index 6c9506b..7b1ef0d 100644
--- a/test/testcase/diffutills/PatchTest.java
+++ b/test/testcase/diffutills/PatchTest.java
@@ -8,39 +8,39 @@
 import difflib.Patch;
 
 public class PatchTest extends TestCase {
-	private List<String> changeTest_from = Arrays.asList("aaa", "bbb", "ccc", "ddd");
-	private List<String> changeTest_to   = Arrays.asList("aaa", "bxb", "cxc", "ddd");
-	
-	private List<String> deleteTest_from = Arrays.asList("ddd", "fff", "ggg", "hhh");
-	private List<String> deleteTest_to   = Arrays.asList("ggg");
-	
-	private List<String> insertTest_from = Arrays.asList("hhh");
-	private List<String> insertTest_to   = Arrays.asList("hhh", "jjj", "kkk", "lll");
-	
-	public void testPatch_Insert() {
-		Patch patch = DiffUtils.diff(insertTest_from, insertTest_to);
-		try {
-			assertEquals(insertTest_to, DiffUtils.patch(insertTest_from, patch));
-		} catch (Exception e) {
-			e.printStackTrace();
-		}
-	}
-	
-	public void testPatch_Delete() {
-		Patch patch = DiffUtils.diff(deleteTest_from, deleteTest_to);
-		try {
-			assertEquals(deleteTest_to, DiffUtils.patch(deleteTest_from, patch));
-		} catch (Exception e) {
-			e.printStackTrace();
-		}
-	}
-	
-	public void testPatch_Change() {
-		Patch patch = DiffUtils.diff(changeTest_from, changeTest_to);
-		try {
-			assertEquals(changeTest_to, DiffUtils.patch(changeTest_from, patch));
-		} catch (Exception e) {
-			e.printStackTrace();
-		}
-	}
+    private List<String> changeTest_from = Arrays.asList("aaa", "bbb", "ccc", "ddd");
+    private List<String> changeTest_to = Arrays.asList("aaa", "bxb", "cxc", "ddd");
+    
+    private List<String> deleteTest_from = Arrays.asList("ddd", "fff", "ggg", "hhh");
+    private List<String> deleteTest_to = Arrays.asList("ggg");
+    
+    private List<String> insertTest_from = Arrays.asList("hhh");
+    private List<String> insertTest_to = Arrays.asList("hhh", "jjj", "kkk", "lll");
+    
+    public void testPatch_Insert() {
+        Patch patch = DiffUtils.diff(insertTest_from, insertTest_to);
+        try {
+            assertEquals(insertTest_to, DiffUtils.patch(insertTest_from, patch));
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+    
+    public void testPatch_Delete() {
+        Patch patch = DiffUtils.diff(deleteTest_from, deleteTest_to);
+        try {
+            assertEquals(deleteTest_to, DiffUtils.patch(deleteTest_from, patch));
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+    
+    public void testPatch_Change() {
+        Patch patch = DiffUtils.diff(changeTest_from, changeTest_to);
+        try {
+            assertEquals(changeTest_to, DiffUtils.patch(changeTest_from, patch));
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
 }