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.

unknown · unknown · commit 1d0b4c4e83df · 2013-07-24T17:36:15.000+01:00
diff --git a/src/main/java/de/danielbechler/diff/CollectionDiffer.java b/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));
diff --git a/src/main/java/de/danielbechler/diff/Configuration.java b/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;
 	}
+
 }
diff --git a/src/main/java/de/danielbechler/diff/Instances.java b/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();
 		}
 	}
+
 }
diff --git a/src/main/java/de/danielbechler/diff/MapDiffer.java b/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());
diff --git a/src/main/java/de/danielbechler/diff/NodeInspector.java b/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);
 
diff --git a/src/main/java/de/danielbechler/diff/accessor/AbstractAccessor.java b/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;
+	}
 
 }
diff --git a/src/main/java/de/danielbechler/diff/accessor/Accessor.java b/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);
+
 }
diff --git a/src/main/java/de/danielbechler/diff/accessor/PropertyDescriptor.java b/src/main/java/de/danielbechler/diff/accessor/PropertyDescriptor.java
@@ -30,4 +30,9 @@ public interface PropertyDescriptor
 	boolean isIgnored();
 
 	boolean isEqualsOnly();
+	
+
+	boolean isWithMethodEquals();
+
+	String getWithMethodEqualsMethod();
 }
diff --git a/src/main/java/de/danielbechler/diff/annotation/ObjectDiffMethodEqualsType.java b/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();
+}
diff --git a/src/main/java/de/danielbechler/diff/annotation/ObjectDiffProperty.java b/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 "";
 }
diff --git a/src/main/java/de/danielbechler/diff/example/MethodEqualExample.java b/src/main/java/de/danielbechler/diff/example/MethodEqualExample.java
@@ -0,0 +1,61 @@
+package de.danielbechler.diff.example;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import de.danielbechler.diff.Configuration;
+import de.danielbechler.diff.ObjectDifferFactory;
+import de.danielbechler.diff.annotation.ObjectDiffProperty;
+import de.danielbechler.diff.example.IgnoreExample.User;
+import de.danielbechler.diff.node.Node;
+import de.danielbechler.diff.path.PropertyPath;
+import de.danielbechler.diff.visitor.PrintingVisitor;
+
+class MethodEqualExample {
+	private MethodEqualExample()
+	{
+	}
+
+	public static void main(final String[] args)
+	{
+		List<Object> baseItems = new ArrayList<Object>();
+		baseItems.add("baseitem");
+		final EncompassingClass base = new EncompassingClass(baseItems);
+		List<Object> workingItems = new ArrayList<Object>();
+		workingItems.add("workingitem");
+		final EncompassingClass working = new EncompassingClass(workingItems);
+
+		final Configuration configuration = new Configuration();
+
+		// (Option 1) Causes the ObjectDiffer to use the method "size" on the 'items' property of the root object
+		configuration.withMethodEqualsProperty(PropertyPath.buildWith("items"), "size");
+
+		final Node node = ObjectDifferFactory.getInstance(configuration).compare(working, base);
+
+		node.visit(new PrintingVisitor(working, base));
+
+		// Output with ignore: 
+		//	Property at path '/' has not changed
+		// Output without ignore: 
+		//	Property at path '/items[workingitem]' has been added => [ workingitem ]
+		//	Property at path '/items[baseitem]' with value [ baseitem ] has been removed
+	}
+
+	public static class EncompassingClass
+	{
+		private final List<Object> items;
+
+		public EncompassingClass(final List<Object> items)
+		{
+			this.items = items;
+		}
+
+		/* (Option 2) This annotation causes the ObjectDiffer to always ignore this property */
+		@ObjectDiffProperty(methodEqual = "size")
+		public List<Object> getItems()
+		{
+			return items;
+		}
+	}
+
+}
diff --git a/src/main/java/de/danielbechler/diff/introspect/StandardIntrospector.java b/src/main/java/de/danielbechler/diff/introspect/StandardIntrospector.java
@@ -99,6 +99,7 @@ private static void handleObjectDiffPropertyAnnotation(final Method readMethod,
 			propertyAccessor.setEqualsOnly(annotation.equalsOnly());
 			propertyAccessor.setIgnored(annotation.ignore());
 			propertyAccessor.setCategories(Collections.setOf(annotation.categories()));
+			propertyAccessor.setWithMethodEqualsMethod(annotation.methodEqual());
 		}
 	}
 
diff --git a/src/main/java/de/danielbechler/diff/node/DefaultNode.java b/src/main/java/de/danielbechler/diff/node/DefaultNode.java
@@ -317,6 +317,14 @@ public final boolean isIgnored()
 	{
 		return state == State.IGNORED || accessor.isIgnored();
 	}
+	
+	public boolean isWithMethodEquals() {
+		return accessor.isWithMethodEquals();
+	}
+
+	public String getWithMethodEqualsMethod() {
+		return accessor.getWithMethodEqualsMethod();
+	}
 
 	public final Set<String> getCategories()
 	{
@@ -474,4 +482,5 @@ public void setCircleStartNode(final Node circleStartNode)
 	{
 		this.circleStartNode = circleStartNode;
 	}
+
 }
diff --git a/src/main/java/de/danielbechler/diff/node/Node.java b/src/main/java/de/danielbechler/diff/node/Node.java
@@ -201,4 +201,8 @@ public enum State
 
 	<T extends Annotation> T getPropertyAnnotation(Class<T> annotationClass);
 
+	boolean isWithMethodEquals();
+
+	String getWithMethodEqualsMethod();
+
 }
diff --git a/src/main/java/de/danielbechler/diff/path/MethodEqualClassAndMethod.java b/src/main/java/de/danielbechler/diff/path/MethodEqualClassAndMethod.java
@@ -0,0 +1,16 @@
+package de.danielbechler.diff.path;
+
+public class MethodEqualClassAndMethod {
+	private Class<?> clazz;
+	private String method;
+	public MethodEqualClassAndMethod(Class<?> clazz, String method){
+		this.clazz = clazz;
+		this.method = method;
+	}
+	public Class<?> getClazz() {
+		return clazz;
+	}
+	public String getMethod() {
+		return method;
+	}
+}
diff --git a/src/main/java/de/danielbechler/diff/path/MethodEqualPropertyPathAndMethod.java b/src/main/java/de/danielbechler/diff/path/MethodEqualPropertyPathAndMethod.java
@@ -0,0 +1,20 @@
+package de.danielbechler.diff.path;
+
+public class MethodEqualPropertyPathAndMethod {
+	private PropertyPath propertyPath;
+	private String method;
+	
+	public MethodEqualPropertyPathAndMethod(){}
+	public MethodEqualPropertyPathAndMethod(PropertyPath propertyPath, String method){
+		this.propertyPath = propertyPath;
+		this.method = method;
+	}
+	
+	public PropertyPath getPropertyPath() {
+		return propertyPath;
+	}
+	
+	public String getMethod() {
+		return method;
+	}
+}

Original file line number	Diff line number	Diff line change
`@@ -61,6 +61,17 @@ else if (nodeInspector.isEqualsOnly(collectionNode))`
`61`	`61`	`collectionNode.setState(Node.State.CHANGED);`
`62`	`62`	`}`
`63`	`63`	`}`
	`64`	`+ else if (nodeInspector.isWithMethodEquals(collectionNode)){`
	`65`	`+ String method = nodeInspector.getWithMethodEqualsMethod(collectionNode);`
	`66`	`+ if (collectionInstances.areMethodResultEqual(method))`
	`67`	`+ {`
	`68`	`+ collectionNode.setState(Node.State.UNTOUCHED);`
	`69`	`+ }`
	`70`	`+ else`
	`71`	`+ {`
	`72`	`+ collectionNode.setState(Node.State.CHANGED);`
	`73`	`+ }`
	`74`	`+ }`
`64`	`75`	`else if (collectionInstances.hasBeenAdded())`
`65`	`76`	`{`
`66`	`77`	`compareItems(collectionNode, collectionInstances, collectionInstances.getWorking(Collection.class));`
Original file line number	Diff line number	Diff line change
`@@ -172,6 +172,19 @@ public boolean areEqual()`
`172`	`172`	`{`
`173`	`173`	`return isEqual(base, working);`
`174`	`174`	`}`
	`175`	`+`
	`176`	`+ public boolean areMethodResultEqual(String method) {`
	`177`	`+ try {`
	`178`	`+ Object baseMethodResult = base.getClass().getMethod(method).invoke(base);`
	`179`	`+ Object workingMethodResult = working.getClass().getMethod(method).invoke(working);`
	`180`	`+ if(baseMethodResult == null){`
	`181`	`+ return workingMethodResult == null;`
	`182`	`+ }`
	`183`	`+ return baseMethodResult.equals(workingMethodResult);`
	`184`	`+ } catch (Exception e) {`
	`185`	`+ throw new RuntimeException(e);`
	`186`	`+ }`
	`187`	`+ }`
`175`	`188`
`176`	`189`	`public boolean areEqualByComparison()`
`177`	`190`	`{`
`@@ -281,4 +294,5 @@ public PropertyPath getPropertyPath(final Node parentNode)`
`281`	`294`	`return PropertyPath.createBuilder().withRoot().build();`
`282`	`295`	`}`
`283`	`296`	`}`
	`297`	`+`
`284`	`298`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,6 +24,7 @@ public abstract class AbstractAccessor implements Accessor`
`24`	`24`	`private Set<String> categories = new TreeSet<String>();`
`25`	`25`	`private boolean equalsOnly;`
`26`	`26`	`private boolean ignored;`
	`27`	`+ private String withMethodEqualsMethod;`
`27`	`28`
`28`	`29`	`public final Set<String> getCategories()`
`29`	`30`	`{`
`@@ -54,5 +55,17 @@ public void setIgnored(final boolean ignored)`
`54`	`55`	`{`
`55`	`56`	`this.ignored = ignored;`
`56`	`57`	`}`
	`58`	`+`
	`59`	`+ public boolean isWithMethodEquals(){`
	`60`	`+ return this.withMethodEqualsMethod != null && !this.withMethodEqualsMethod.equals("");`
	`61`	`+ }`
	`62`	`+`
	`63`	`+ public void setWithMethodEqualsMethod(String withMethodEqualsMethod) {`
	`64`	`+ this.withMethodEqualsMethod = withMethodEqualsMethod;`
	`65`	`+ }`
	`66`	`+`
	`67`	`+ public String getWithMethodEqualsMethod(){`
	`68`	`+ return withMethodEqualsMethod;`
	`69`	`+ }`
`57`	`70`
`58`	`71`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,4 +24,5 @@ public interface Accessor extends PropertyDescriptor`
`24`	`24`	`void set(Object target, Object value);`
`25`	`25`
`26`	`26`	`void unset(Object target);`
	`27`	`+`
`27`	`28`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,4 +30,9 @@ public interface PropertyDescriptor`
`30`	`30`	`boolean isIgnored();`
`31`	`31`
`32`	`32`	`boolean isEqualsOnly();`
	`33`	`+`
	`34`	`+`
	`35`	`+ boolean isWithMethodEquals();`
	`36`	`+`
	`37`	`+ String getWithMethodEqualsMethod();`
`33`	`38`	`}`
Original file line number	Diff line number	Diff line change
`@@ -51,4 +51,6 @@`
`51`	`51`	`* @return The categories for this property.`
`52`	`52`	`*/`
`53`	`53`	`public String[] categories() default {};`
	`54`	`+`
	`55`	`+ public String methodEqual() default "";`
`54`	`56`	`}`