add possibility to use comparable interface to compare two objects.

Author: Jean-Eudes

src/main/java/de/danielbechler/diff/BeanDiffer.java

@@ -76,6 +76,10 @@ private void compareUsingAppropriateMethod(final Node beanNode, final Instances
 		{
 			compareUsingIntrospection(beanNode, instances);
 		}
+		else if (nodeInspector.isComparable(beanNode))
+		{
+			compareUsingCompare(beanNode, instances);
+		}
 		else if (nodeInspector.isEqualsOnly(beanNode))
 		{
 			compareUsingEquals(beanNode, instances);
@@ -109,6 +113,18 @@ private void compareUsingEquals(final Node beanNode, final Instances instances)
 		}
 	}
 
+	private void compareUsingCompare(final Node beanNode, final Instances instances)
+	{
+		if (instances.areComparable())
+		{
+			beanNode.setState(Node.State.UNTOUCHED);
+		}
+		else
+		{
+			beanNode.setState(Node.State.CHANGED);
+		}
+	}
+
 	@TestOnly
 	void setIntrospector(final Introspector introspector)
 	{

src/main/java/de/danielbechler/diff/Configuration.java

@@ -78,6 +78,8 @@ public enum PrimitiveDefaultValueMode
 	private final Collection<PropertyPath> excludedProperties = new HashSet<PropertyPath>(10);
 	private final Collection<PropertyPath> equalsOnlyProperties = new LinkedHashSet<PropertyPath>(10);
 	private final Collection<Class<?>> equalsOnlyTypes = new LinkedHashSet<Class<?>>(10);
+	private final Collection<Class<?>> comparableTypes = new LinkedHashSet<Class<?>>(10);
+	private final Map<Class<?>, Comparator<?>> compareTypes = new HashMap<Class<?>, Comparator<?>>(10);
 	private boolean returnUnchangedNodes = false;
 	private boolean returnIgnoredNodes = false;
 	private boolean returnCircularNodes = true;
@@ -130,6 +132,18 @@ public Configuration withEqualsOnlyType(final Class<?> type)
 		return this;
 	}
 
+	public Configuration withComparableType(final Class<?> type)
+	{
+		this.comparableTypes.add(type);
+		return this;
+	}
+
+	public Configuration withCompareType(final Class<?> type, Comparator<?> comparator)
+	{
+		this.compareTypes.put(type, comparator);
+		return this;
+	}
+
 	public Configuration withEqualsOnlyProperty(final PropertyPath propertyPath)
 	{
 		this.equalsOnlyProperties.add(propertyPath);
@@ -286,6 +300,7 @@ public boolean isEqualsOnly(final Node node)
 		return false;
 	}
 
+
 	public boolean isReturnable(final Node node)
 	{
 		if (node.isIgnored())
@@ -311,12 +326,20 @@ else if (node.hasChildren())
 		return true;
 	}
 
-	public boolean isIntrospectible(final Node node)
+    public boolean isComparable(Node node) {
+        return comparableTypes.contains(node.getType()) && Comparable.class.isAssignableFrom(node.getType());
+    }
+
+    public boolean isIntrospectible(final Node node)
 	{
 		if (isEqualsOnly(node))
 		{
 			return false;
 		}
+        else if (isComparable(node))
+		{
+			return false;
+		}
 		else if (node.isAdded())
 		{
 			return returnChildrenOfAddedNodes;

src/main/java/de/danielbechler/diff/Instances.java

@@ -172,7 +172,16 @@ public boolean areEqual()
 		return isEqual(base, working);
 	}
 
-	public boolean areSame()
+    public boolean areComparable()
+	{
+		return areComparable((Comparable) base, (Comparable) working);
+	}
+
+    private boolean areComparable(Comparable base, Comparable working) {
+        return base.compareTo(working) == 0;
+    }
+
+    public boolean areSame()
 	{
 		return working == base;
 	}

src/main/java/de/danielbechler/diff/NodeInspector.java

@@ -31,6 +31,8 @@ interface NodeInspector
 
 	boolean isReturnable(Node node);
 
+    boolean isComparable(Node node);
+
 	/**
 	 * @return Returns <code>true</code> if the object represented by the given node should be compared via
 	 *         introspection. It must always return </code><code>false</code> if {@link

src/test/java/de/danielbechler/diff/BeanDifferShould.java

@@ -24,6 +24,8 @@
 import org.mockito.Mock;
 import org.testng.annotations.*;
 
+import java.math.BigDecimal;
+
 import static de.danielbechler.diff.node.NodeAssertions.assertThat;
 import static java.util.Arrays.*;
 import static org.hamcrest.MatcherAssert.assertThat;
@@ -109,6 +111,32 @@ public void compare_bean_via_equals()
 		assertThat(node).self().isUntouched();
 	}
 
+	@Test
+	public void compare_bean_via_comparable_when_same_value()
+	{
+		final BigDecimal working = new BigDecimal("1.0");
+		final BigDecimal base = new BigDecimal("1.00");
+		configuration.withComparableType(BigDecimal.class);
+
+		final Node node = differ.compare(Node.ROOT, Instances.of(working, base));
+
+		assertThat(node).self().isUntouched();
+	}
+
+	@Test
+	public void compare_bean_via_comparable_when_different_value()
+	{
+		final BigDecimal working = new BigDecimal("1.0");
+		final BigDecimal base = new BigDecimal("1.01");
+		configuration.withComparableType(BigDecimal.class);
+
+		final Node node = differ.compare(Node.ROOT, Instances.of(working, base));
+
+		assertThat(node).self().hasChanges();
+	}
+
+
+
 	@Test
 	public void compare_bean_via_introspection_and_delegate_comparison_of_properties()
 	{

src/test/java/de/danielbechler/diff/ConfigurationTest.java

@@ -189,7 +189,35 @@ public void testIsIntrospectibleReturnsFalseForRemovedNodeIfChildrenOfRemovedNod
 		assertThat(configuration.isIntrospectible(node)).isFalse();
 	}
 
-	@SuppressWarnings({"TypeMayBeWeakened"})
+    @Test
+    public void testIsComparableWithAComparableObjectAddedInConfiguration() throws Exception
+    {
+        final Class aClass = ObjectImplementComparable.class;
+        this.configuration.withComparableType(aClass);
+        when(node.getType()).thenReturn(aClass);
+
+        assertThat(this.configuration.isComparable(node), is(true));
+    }
+
+    @Test
+    public void testIsComparableWithAComparableObjectNotAddedInConfiguration() throws Exception
+    {
+        final Class aClass = ObjectImplementComparable.class;
+        when(node.getType()).thenReturn(aClass);
+
+        assertThat(this.configuration.isComparable(node), is(false));
+    }
+
+    @Test
+    public void testIsNotComparableWithANotComparableObject() throws Exception
+    {
+        final Class aClass = Object.class;
+        when(node.getType()).thenReturn(aClass);
+
+        assertThat(this.configuration.isComparable(node), is(false));
+    }
+
+    @SuppressWarnings({"TypeMayBeWeakened"})
 	private static <T> Answer<Class<T>> returnClass(final Class<T> aClass)
 	{
 		return new Answer<Class<T>>()

src/test/java/de/danielbechler/diff/mock/ObjectImplementComparable.java

@@ -0,0 +1,9 @@
+package de.danielbechler.diff.mock;
+
+public class ObjectImplementComparable implements Comparable<ObjectImplementComparable> {
+
+    public int compareTo(ObjectImplementComparable o) {
+        return 0;
+    }
+
+}