adding ability to compare by the result of a given method on a property. shown in MethodEqualExample. Had trouble getting spock and testng in my dev environment. will look further into this tomorrow to ensure not broken stuff and to get some coverage for this.

Author: unknown

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

@@ -61,6 +61,17 @@ else if (nodeInspector.isEqualsOnly(collectionNode))
 				collectionNode.setState(Node.State.CHANGED);
 			}
 		}
+		else if (nodeInspector.isWithMethodEquals(collectionNode)){
+			String method = nodeInspector.getWithMethodEqualsMethod(collectionNode);
+			if (collectionInstances.areMethodResultEqual(method))
+			{
+				collectionNode.setState(Node.State.UNTOUCHED);
+			}
+			else
+			{
+				collectionNode.setState(Node.State.CHANGED);
+			}
+		}
 		else if (collectionInstances.hasBeenAdded())
 		{
 			compareItems(collectionNode, collectionInstances, collectionInstances.getWorking(Collection.class));

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

@@ -20,6 +20,7 @@
 import de.danielbechler.diff.node.*;
 import de.danielbechler.diff.path.*;
 import de.danielbechler.util.*;
+import groovy.lang.Tuple;
 
 import java.util.*;
 
@@ -77,8 +78,10 @@ public enum PrimitiveDefaultValueMode
 	private final Collection<PropertyPath> includedProperties = new HashSet<PropertyPath>(10);
 	private final Collection<PropertyPath> excludedProperties = new HashSet<PropertyPath>(10);
 	private final Collection<PropertyPath> equalsOnlyProperties = new LinkedHashSet<PropertyPath>(10);
+	private final Collection<MethodEqualPropertyPathAndMethod> methodEqualProperties = new LinkedHashSet<MethodEqualPropertyPathAndMethod>(10);
     private final Collection<Class<?>> compareToOnlyTypes = new LinkedHashSet<Class<?>>(10);
 	private final Collection<Class<?>> equalsOnlyTypes = new LinkedHashSet<Class<?>>(10);
+	private final Collection<MethodEqualClassAndMethod> methodEqualTypes = new LinkedHashSet<MethodEqualClassAndMethod>(10);
 	private boolean returnUnchangedNodes = false;
 	private boolean returnIgnoredNodes = false;
 	private boolean returnCircularNodes = true;
@@ -124,7 +127,7 @@ public Configuration withoutProperty(final PropertyPath propertyPath)
 		this.excludedProperties.add(propertyPath);
 		return this;
 	}
-
+	
     public Configuration withCompareToOnlyType(final Class<?> type)
     {
         this.compareToOnlyTypes.add(type);
@@ -143,12 +146,22 @@ public Configuration withEqualsOnlyProperty(final PropertyPath propertyPath)
 		return this;
 	}
 
+	public Configuration withMethodEqualsProperty(final PropertyPath propertyPath, final String methodName) {
+		this.methodEqualProperties.add(new MethodEqualPropertyPathAndMethod(propertyPath, methodName));
+		return this;
+	}
+	
+	public Configuration withMethodEqualsProperty(MethodEqualPropertyPathAndMethod propertyPathEqualsMethod) {
+		this.methodEqualProperties.add(propertyPathEqualsMethod);
+		return this;
+	}
+	
 	public Configuration withIgnoredNodes()
 	{
 		this.returnIgnoredNodes = true;
 		return this;
 	}
-
+	
 	public Configuration withoutIgnoredNodes()
 	{
 		this.returnIgnoredNodes = false;
@@ -309,6 +322,57 @@ public boolean isEqualsOnly(final Node node)
 		}
 		return false;
 	}
+	
+	public boolean isWithMethodEquals(Node node){
+		return getWithMethodEqualsMethod(node) != null;
+	}
+	
+	public String getWithMethodEqualsMethod(Node node){
+		final Class<?> propertyType = node.getType();
+		if (propertyType != null)
+		{
+			ObjectDiffMethodEqualsType annotation = propertyType.getAnnotation(ObjectDiffMethodEqualsType.class);
+			if (annotation != null)
+			{
+				return annotation.method();
+			}
+			
+			MethodEqualClassAndMethod applicable = findMethodEqualPropertyForClass(propertyType);
+			if (applicable != null)
+			{
+				return applicable.getMethod();
+			}
+		}
+		if (node.isWithMethodEquals())
+		{
+			return node.getWithMethodEqualsMethod();
+		}
+		MethodEqualPropertyPathAndMethod applicable = findMethodEqualPropertyForPath(node.getPropertyPath());
+		if (applicable != null)
+		{
+			return applicable.getMethod();
+		}
+		return null;
+	}
+	
+	private MethodEqualClassAndMethod findMethodEqualPropertyForClass(Class<?> clazz){
+		for(MethodEqualClassAndMethod propertyPathEqualsMethod: methodEqualTypes){
+			if(clazz.equals(propertyPathEqualsMethod.getClazz())){
+				return propertyPathEqualsMethod;
+			}
+		}
+		return null;
+			
+	}
+	
+	private MethodEqualPropertyPathAndMethod findMethodEqualPropertyForPath(PropertyPath propertyPath){
+		for(MethodEqualPropertyPathAndMethod propertyPathEqualsMethod: methodEqualProperties){
+			if(propertyPath.equals(propertyPathEqualsMethod.getPropertyPath())){
+				return propertyPathEqualsMethod;
+			}
+		}
+		return null;
+	}
 
 	public boolean isReturnable(final Node node)
 	{
@@ -347,4 +411,5 @@ else if (node.isRemoved())
 		}
 		return true;
 	}
+
 }

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

@@ -172,6 +172,19 @@ public boolean areEqual()
 	{
 		return isEqual(base, working);
 	}
+	
+	public boolean areMethodResultEqual(String method) {
+		try {
+			Object baseMethodResult = base.getClass().getMethod(method).invoke(base);
+			Object workingMethodResult = working.getClass().getMethod(method).invoke(working);
+			if(baseMethodResult == null){
+				return workingMethodResult == null;
+			}
+			return baseMethodResult.equals(workingMethodResult);
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+		}
+	}
 
     public boolean areEqualByComparison()
 	{
@@ -281,4 +294,5 @@ public PropertyPath getPropertyPath(final Node parentNode)
 			return PropertyPath.createBuilder().withRoot().build();
 		}
 	}
+
 }

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

@@ -21,6 +21,7 @@
 import de.danielbechler.util.*;
 import de.danielbechler.util.Collections;
 
+import java.lang.reflect.InvocationTargetException;
 import java.util.*;
 
 /**
@@ -61,6 +62,17 @@ else if (nodeInspector.isEqualsOnly(mapNode))
 				mapNode.setState(Node.State.CHANGED);
 			}
 		}
+		else if (nodeInspector.isWithMethodEquals(mapNode)){
+			String method = nodeInspector.getWithMethodEqualsMethod(mapNode);
+			if (instances.areMethodResultEqual(method))
+			{
+				mapNode.setState(Node.State.UNTOUCHED);
+			}
+			else
+			{
+				mapNode.setState(Node.State.CHANGED);
+			}
+		}
 		else if (instances.hasBeenAdded())
 		{
 			compareEntries(mapNode, instances, instances.getWorking(Map.class).keySet());

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

@@ -30,6 +30,9 @@ interface NodeInspector
     boolean isCompareToOnly(Node node);
 
 	boolean isEqualsOnly(Node node);
+	
+	boolean isWithMethodEquals(Node node);
+	String getWithMethodEqualsMethod(Node node);
 
 	boolean isReturnable(Node node);
 

src/main/java/de/danielbechler/diff/accessor/AbstractAccessor.java

@@ -24,6 +24,7 @@ public abstract class AbstractAccessor implements Accessor
 	private Set<String> categories = new TreeSet<String>();
 	private boolean equalsOnly;
 	private boolean ignored;
+	private String withMethodEqualsMethod;
 
 	public final Set<String> getCategories()
 	{
@@ -54,5 +55,17 @@ public void setIgnored(final boolean ignored)
 	{
 		this.ignored = ignored;
 	}
+	
+	public boolean isWithMethodEquals(){
+		return this.withMethodEqualsMethod != null && !this.withMethodEqualsMethod.equals("");
+	}
+
+	public void setWithMethodEqualsMethod(String withMethodEqualsMethod) {
+		this.withMethodEqualsMethod = withMethodEqualsMethod;
+	}
+	
+	public String getWithMethodEqualsMethod(){
+		return withMethodEqualsMethod;
+	}
 
 }

src/main/java/de/danielbechler/diff/accessor/Accessor.java

@@ -24,4 +24,5 @@ public interface Accessor extends PropertyDescriptor
 	void set(Object target, Object value);
 
 	void unset(Object target);
+
 }

src/main/java/de/danielbechler/diff/accessor/PropertyDescriptor.java

@@ -30,4 +30,9 @@ public interface PropertyDescriptor
 	boolean isIgnored();
 
 	boolean isEqualsOnly();
+	
+
+	boolean isWithMethodEquals();
+
+	String getWithMethodEqualsMethod();
 }

src/main/java/de/danielbechler/diff/annotation/ObjectDiffMethodEqualsType.java

@@ -0,0 +1,15 @@
+package de.danielbechler.diff.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+@Inherited
+@ObjectDiffAnnotation
+public @interface ObjectDiffMethodEqualsType {
+	public String method();
+}

src/main/java/de/danielbechler/diff/annotation/ObjectDiffProperty.java

@@ -51,4 +51,6 @@
 	 * @return The categories for this property.
 	 */
 	public String[] categories() default {};
+	
+	public String methodEqual() default "";
 }