renaming methods, annotations and properties following discussion on the pull request

Author: unknown

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

@@ -49,9 +49,9 @@ public final Node compare(final Node parentNode, final Instances instances)
 		{
 			beanNode.setState(Node.State.IGNORED);
 		}
-		else if (nodeInspector.isWithMethodEquals(beanNode)){
-			String method = nodeInspector.getWithMethodEqualsMethod(beanNode);
-			if (instances.areMethodResultEqual(method))
+		else if (nodeInspector.hasEqualsOnlyValueProviderMethod(beanNode)){
+			String method = nodeInspector.getEqualsOnlyValueProviderMethod(beanNode);
+			if (instances.areMethodResultsEqual(method))
 			{
 				beanNode.setState(Node.State.UNTOUCHED);
 			}

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

@@ -61,9 +61,9 @@ else if (nodeInspector.isEqualsOnly(collectionNode))
 				collectionNode.setState(Node.State.CHANGED);
 			}
 		}
-		else if (nodeInspector.isWithMethodEquals(collectionNode)){
-			String method = nodeInspector.getWithMethodEqualsMethod(collectionNode);
-			if (collectionInstances.areMethodResultEqual(method))
+		else if (nodeInspector.hasEqualsOnlyValueProviderMethod(collectionNode)){
+			String method = nodeInspector.getEqualsOnlyValueProviderMethod(collectionNode);
+			if (collectionInstances.areMethodResultsEqual(method))
 			{
 				collectionNode.setState(Node.State.UNTOUCHED);
 			}

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

@@ -77,10 +77,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<PropertyPathAndMethod> methodEqualProperties = new LinkedHashSet<PropertyPathAndMethod>(10);
+	private final Collection<PropertyPathAndMethod> equalsOnlyValueProviderMethods = new LinkedHashSet<PropertyPathAndMethod>(10);
     private final Collection<Class<?>> compareToOnlyTypes = new LinkedHashSet<Class<?>>(10);
 	private final Collection<Class<?>> equalsOnlyTypes = new LinkedHashSet<Class<?>>(10);
-	private final Collection<ClassAndMethod> methodEqualTypes = new LinkedHashSet<ClassAndMethod>(10);
+	private final Collection<ClassAndMethod> equalsOnlyValueProviderTypes = new LinkedHashSet<ClassAndMethod>(10);
 	private boolean returnUnchangedNodes = false;
 	private boolean returnIgnoredNodes = false;
 	private boolean returnCircularNodes = true;
@@ -145,13 +145,13 @@ public Configuration withEqualsOnlyProperty(final PropertyPath propertyPath)
 		return this;
 	}
 
-	public Configuration withMethodEqualsProperty(final PropertyPath propertyPath, final String methodName) {
-		this.methodEqualProperties.add(new PropertyPathAndMethod(propertyPath, methodName));
+	public Configuration withEqualsOnlyValueProviderMethod(final PropertyPath propertyPath, final String methodName) {
+		this.equalsOnlyValueProviderMethods.add(new PropertyPathAndMethod(propertyPath, methodName));
 		return this;
 	}
 
-	public Configuration withMethodEqualsProperty(PropertyPathAndMethod propertyPathEqualsMethod) {
-		this.methodEqualProperties.add(propertyPathEqualsMethod);
+	public Configuration withEqualsOnlyValueProviderMethod(PropertyPathAndMethod propertyPathEqualsMethod) {
+		this.equalsOnlyValueProviderMethods.add(propertyPathEqualsMethod);
 		return this;
 	}
 
@@ -322,52 +322,52 @@ public boolean isEqualsOnly(final Node node)
 		return false;
 	}
 
-	public boolean isWithMethodEquals(Node node){
-		return getWithMethodEqualsMethod(node) != null;
+	public boolean hasEqualsOnlyValueProviderMethod(Node node){
+		return getEqualsOnlyValueProviderMethod(node) != null;
 	}
 
-	public String getWithMethodEqualsMethod(Node node){
+	public String getEqualsOnlyValueProviderMethod(Node node){
 		final Class<?> propertyType = node.getType();
 		if (propertyType != null)
 		{
-			ObjectDiffMethodEqualsType annotation = propertyType.getAnnotation(ObjectDiffMethodEqualsType.class);
+			ObjectDiffEqualsOnlyValueProvidedType annotation = propertyType.getAnnotation(ObjectDiffEqualsOnlyValueProvidedType.class);
 			if (annotation != null)
 			{
 				return annotation.method();
 			}
 
-			ClassAndMethod applicable = findMethodEqualPropertyForClass(propertyType);
+			ClassAndMethod applicable = findEqualsOnlyValueProviderMethodForClass(propertyType);
 			if (applicable != null)
 			{
 				return applicable.getMethod();
 			}
 		}
-		if (node.isWithMethodEquals())
+		if (node.hasEqualsOnlyValueProviderMethod())
 		{
-			return node.getWithMethodEqualsMethod();
+			return node.getEqualsOnlyValueProviderMethod();
 		}
-		PropertyPathAndMethod applicable = findMethodEqualPropertyForPath(node.getPropertyPath());
+		PropertyPathAndMethod applicable = findEqualsOnlyValueProviderMethodForPath(node.getPropertyPath());
 		if (applicable != null)
 		{
 			return applicable.getMethod();
 		}
 		return null;
 	}
 
-	private ClassAndMethod findMethodEqualPropertyForClass(Class<?> clazz){
-		for(ClassAndMethod propertyPathEqualsMethod: methodEqualTypes){
-			if(clazz.equals(propertyPathEqualsMethod.getClazz())){
-				return propertyPathEqualsMethod;
+	private ClassAndMethod findEqualsOnlyValueProviderMethodForClass(Class<?> clazz){
+		for(ClassAndMethod propertyPathEqualsOnValueProviderType: equalsOnlyValueProviderTypes){
+			if(clazz.equals(propertyPathEqualsOnValueProviderType.getClazz())){
+				return propertyPathEqualsOnValueProviderType;
 			}
 		}
 		return null;
 
 	}
 
-	private PropertyPathAndMethod findMethodEqualPropertyForPath(PropertyPath propertyPath){
-		for(PropertyPathAndMethod propertyPathEqualsMethod: methodEqualProperties){
-			if(propertyPath.equals(propertyPathEqualsMethod.getPropertyPath())){
-				return propertyPathEqualsMethod;
+	private PropertyPathAndMethod findEqualsOnlyValueProviderMethodForPath(PropertyPath propertyPath){
+		for(PropertyPathAndMethod propertyPathEqualsOnValueProviderMethod: equalsOnlyValueProviderMethods){
+			if(propertyPath.equals(propertyPathEqualsOnValueProviderMethod.getPropertyPath())){
+				return propertyPathEqualsOnValueProviderMethod;
 			}
 		}
 		return null;

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

@@ -173,7 +173,7 @@ public boolean areEqual()
 		return isEqual(base, working);
 	}
 
-	public boolean areMethodResultEqual(String method) {
+	public boolean areMethodResultsEqual(String method) {
 		try {
 			Object baseMethodResult = base.getClass().getMethod(method).invoke(base);
 			Object workingMethodResult = working.getClass().getMethod(method).invoke(working);
@@ -294,5 +294,4 @@ public PropertyPath getPropertyPath(final Node parentNode)
 			return PropertyPath.createBuilder().withRoot().build();
 		}
 	}
-
 }

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

@@ -61,9 +61,9 @@ else if (nodeInspector.isEqualsOnly(mapNode))
 				mapNode.setState(Node.State.CHANGED);
 			}
 		}
-		else if (nodeInspector.isWithMethodEquals(mapNode)){
-			String method = nodeInspector.getWithMethodEqualsMethod(mapNode);
-			if (instances.areMethodResultEqual(method))
+		else if (nodeInspector.hasEqualsOnlyValueProviderMethod(mapNode)){
+			String method = nodeInspector.getEqualsOnlyValueProviderMethod(mapNode);
+			if (instances.areMethodResultsEqual(method))
 			{
 				mapNode.setState(Node.State.UNTOUCHED);
 			}

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

@@ -31,8 +31,9 @@ interface NodeInspector
 
 	boolean isEqualsOnly(Node node);
 
-	boolean isWithMethodEquals(Node node);
-	String getWithMethodEqualsMethod(Node node);
+	boolean hasEqualsOnlyValueProviderMethod(Node node);
+	
+	String getEqualsOnlyValueProviderMethod(Node node);
 
 	boolean isReturnable(Node node);
 

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

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

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

@@ -24,5 +24,4 @@ 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,9 +30,8 @@ public interface PropertyDescriptor
 	boolean isIgnored();
 
 	boolean isEqualsOnly();
-	
 
-	boolean isWithMethodEquals();
+	boolean hasEqualsOnlyValueProviderMethod();
 
-	String getWithMethodEqualsMethod();
+	String getEqualsOnlyValueProviderMethod();
 }

src/main/java/de/danielbechler/diff/annotation/ObjectDiffMethodEqualsType.java renamed to src/main/java/de/danielbechler/diff/annotation/ObjectDiffEqualsOnlyValueProvidedType.java

@@ -10,6 +10,6 @@
 @Target(ElementType.TYPE)
 @Inherited
 @ObjectDiffAnnotation
-public @interface ObjectDiffMethodEqualsType {
+public @interface ObjectDiffEqualsOnlyValueProvidedType {
 	public String method();
 }