added category resolution on compare

src/integration-test/java/de/danielbechler/diff/categories/CategoriesTestIT.groovy

@@ -0,0 +1,49 @@
+package de.danielbechler.diff.categories
+
+import de.danielbechler.diff.ObjectDifferBuilder
+import de.danielbechler.diff.introspection.ObjectDiffProperty
+import de.danielbechler.diff.node.DiffNode
+import de.danielbechler.diff.node.Visit
+import de.danielbechler.diff.path.NodePath
+import spock.lang.Specification
+
+class CategoriesTestIT extends Specification{
+
+	def obj1 = new MyObject("aaa","aaa", "aaa")
+	def obj2 =  new MyObject("bbb","bbb", "bbb")
+	def differ = ObjectDifferBuilder.startBuilding()
+			.categories()
+			.ofNode(NodePath.with("firstString")).toBe("cat1")
+			.ofNode(NodePath.with("secondString")).toBe("cat1")
+			.ofNode(NodePath.with("thirdString")).toBe("cat1")
+			.and()
+			.build()
+
+	def "should return all categories"(){
+		given:
+			def node = differ.compare(obj1,obj2)
+		expect :
+			node.getChild("firstString").getCategories() == ["cat1"] as Set
+			node.getChild("secondString").getCategories() == ["cat1"] as Set
+			node.getChild("thirdString").getCategories() == ["cat1", "catAnnotation"] as Set
+	}
+
+	class MyObject{
+
+		def firstString
+        def secondString
+		def thirdString
+
+		MyObject(firstString,secondString,thirdString) {
+
+			this.firstString = firstString
+			this.secondString = secondString
+			this.thirdString = thirdString
+		}
+
+        @ObjectDiffProperty(categories = ["catAnnotation"])
+		def getThirdString() {
+			return thirdString
+		}
+	}
+}

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

@@ -160,7 +160,8 @@ public ObjectDiffer build()
 				circularReferenceService,
 				inclusionService,
 				returnableNodeService,
-				introspectionService);
+				introspectionService,
+				categoryService);
 		differProvider.push(new BeanDiffer(
 				differDispatcher,
 				introspectionService,

src/main/java/de/danielbechler/diff/differ/DifferDispatcher.java

@@ -19,6 +19,7 @@
 import de.danielbechler.diff.access.Accessor;
 import de.danielbechler.diff.access.Instances;
 import de.danielbechler.diff.access.PropertyAwareAccessor;
+import de.danielbechler.diff.category.CategoryResolver;
 import de.danielbechler.diff.introspection.PropertyReadException;
 import de.danielbechler.diff.circular.CircularReferenceDetector;
 import de.danielbechler.diff.circular.CircularReferenceDetectorFactory;
@@ -46,6 +47,7 @@ public class DifferDispatcher
 	private final CircularReferenceDetectorFactory circularReferenceDetectorFactory;
 	private final CircularReferenceExceptionHandler circularReferenceExceptionHandler;
 	private final IsIgnoredResolver isIgnoredResolver;
+	private final CategoryResolver categoryResolver;
 	private final IsReturnableResolver isReturnableResolver;
 	private final PropertyAccessExceptionHandlerResolver propertyAccessExceptionHandlerResolver;
 	private static final ThreadLocal<CircularReferenceDetector> workingThreadLocal = new ThreadLocal<CircularReferenceDetector>();
@@ -56,14 +58,18 @@ public DifferDispatcher(final DifferProvider differProvider,
 							final CircularReferenceExceptionHandler circularReferenceExceptionHandler,
 							final IsIgnoredResolver ignoredResolver,
 							final IsReturnableResolver returnableResolver,
-							final PropertyAccessExceptionHandlerResolver propertyAccessExceptionHandlerResolver)
+							final PropertyAccessExceptionHandlerResolver propertyAccessExceptionHandlerResolver,
+							final CategoryResolver categoryResolver)
 	{
 		Assert.notNull(differProvider, "differFactory");
 		this.differProvider = differProvider;
 
 		Assert.notNull(ignoredResolver, "ignoredResolver");
 		this.isIgnoredResolver = ignoredResolver;
 
+		Assert.notNull(categoryResolver, "categoryResolver");
+		this.categoryResolver = categoryResolver;
+
 		this.circularReferenceDetectorFactory = circularReferenceDetectorFactory;
 		this.circularReferenceExceptionHandler = circularReferenceExceptionHandler;
 		this.isReturnableResolver = returnableResolver;
@@ -101,6 +107,10 @@ public DiffNode dispatch(final DiffNode parentNode,
 		{
 			parentNode.addChild(node);
 		}
+		if(node != null)
+		{
+			node.addCategories(categoryResolver.resolveCategories(node));
+		}
 		return node;
 	}
 

src/main/java/de/danielbechler/diff/inclusion/InclusionService.java

@@ -24,6 +24,7 @@
 
 import java.util.Collection;
 import java.util.LinkedList;
+import java.util.Set;
 
 import static de.danielbechler.diff.inclusion.Inclusion.DEFAULT;
 import static de.danielbechler.diff.inclusion.Inclusion.EXCLUDED;
@@ -279,4 +280,5 @@ public ObjectDifferBuilder and()
 	{
 		return rootConfiguration;
 	}
+
 }

src/main/java/de/danielbechler/diff/node/DiffNode.java

@@ -32,12 +32,7 @@
 import de.danielbechler.util.Assert;
 
 import java.lang.annotation.Annotation;
-import java.util.Collections;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.TreeSet;
+import java.util.*;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import static java.util.Collections.unmodifiableSet;
@@ -67,6 +62,7 @@ public class DiffNode
 	private Class<?> valueType;
 	private TypeInfo valueTypeInfo;
 	private IdentityStrategy childIdentityStrategy;
+	private final Set<String> additionalCategories = new TreeSet<String>();
 
 	public void setChildIdentityStrategy(final IdentityStrategy identityStrategy)
 	{
@@ -573,7 +569,10 @@ public boolean isExcluded()
 		return false;
 	}
 
-	// TODO These categories should also contain the ones configured via CategoryService
+	/**
+	 * Returns a {@link java.util.Set} of {@link java.lang.String}
+	 * @return
+     */
 	public final Set<String> getCategories()
 	{
 		final Set<String> categories = new TreeSet<String>();
@@ -589,7 +588,9 @@ public final Set<String> getCategories()
 				categories.addAll(categoriesFromAccessor);
 			}
 		}
-		return categories;
+		categories.addAll(additionalCategories);
+
+		return Collections.unmodifiableSet(categories);
 	}
 
 	/**
@@ -732,6 +733,12 @@ else if (childCount() > 1)
 		return sb.toString();
 	}
 
+	public void addCategories(final Collection<String> additionalCategories)
+	{
+		Assert.notNull(additionalCategories, "additionalCategories");
+		this.additionalCategories.addAll(additionalCategories);
+	}
+
 	/**
 	 * @return Returns the path to the first node in the hierarchy that represents the same object instance as
 	 * this one. (Only if {@link #isCircular()} returns <code>true</code>.

src/test/java/de/danielbechler/diff/differ/DifferDispatcherShould.java

@@ -19,6 +19,7 @@
 import de.danielbechler.diff.access.Accessor;
 import de.danielbechler.diff.access.Instances;
 import de.danielbechler.diff.access.RootAccessor;
+import de.danielbechler.diff.category.CategoryResolver;
 import de.danielbechler.diff.circular.CircularReferenceDetector;
 import de.danielbechler.diff.circular.CircularReferenceDetectorFactory;
 import de.danielbechler.diff.circular.CircularReferenceExceptionHandler;
@@ -62,6 +63,8 @@ public class DifferDispatcherShould
 	@Mock
 	private IsIgnoredResolver ignoredResolver;
 	@Mock
+	private CategoryResolver categoryResolver;
+	@Mock
 	private IsReturnableResolver returnableResolver;
 	@Mock
 	private Instances instances;
@@ -79,7 +82,7 @@ public void setUp() throws Exception
 		when(instances.access(any(Accessor.class))).thenReturn(accessedInstances);
 		when(accessedInstances.getSourceAccessor()).thenReturn(accessor);
 
-		differDispatcher = new DifferDispatcher(differProvider, circularReferenceDetectorFactory, circularReferenceExceptionHandler, ignoredResolver, returnableResolver, propertyAccessExceptionHandlerResolver);
+		differDispatcher = new DifferDispatcher(differProvider, circularReferenceDetectorFactory, circularReferenceExceptionHandler, ignoredResolver, returnableResolver, propertyAccessExceptionHandlerResolver, categoryResolver);
 	}
 
 	@Test

src/test/java/de/danielbechler/diff/differ/DifferDispatcherTest.groovy

@@ -17,6 +17,7 @@
 package de.danielbechler.diff.differ
 
 import de.danielbechler.diff.access.*
+import de.danielbechler.diff.category.CategoryResolver
 import de.danielbechler.diff.circular.CircularReferenceDetector
 import de.danielbechler.diff.circular.CircularReferenceDetectorFactory
 import de.danielbechler.diff.circular.CircularReferenceExceptionHandler
@@ -53,14 +54,18 @@ class DifferDispatcherTest extends Specification {
 	def isReturnableResolver = Stub IsReturnableResolver, {
 		isReturnable(_ as DiffNode) >> true
 	}
+	def categoryResolver = Stub CategoryResolver, {
+		resolveCategories(_ as DiffNode) >> Collections.emptySet()
+	}
 	def propertyAccessExceptionHandlerResolver = Mock PropertyAccessExceptionHandlerResolver
 	def differDispatcher = new DifferDispatcher(
 			differProvider,
 			circularReferenceDetectorFactory,
 			circularReferenceExceptionHandler,
 			isIgnoredResolver,
 			isReturnableResolver,
-			propertyAccessExceptionHandlerResolver)
+			propertyAccessExceptionHandlerResolver,
+			categoryResolver)
 
 	@Ignore
 	def "when a circular reference is detected"() {

src/test/java/de/danielbechler/diff/node/DiffNodeTest.groovy

@@ -245,4 +245,32 @@ class DiffNodeTest extends Specification {
 
 		  doesOrDoesNotImplement = expectedResult ? 'implements' : 'does not implement'
 	}
+
+	def "should return categories added when visiting"(){
+		given:
+			def node = new DiffNode(null, Mock(Accessor), Object)
+			node.addCategories(["addedCategory"] as List)
+		expect :
+			node.getCategories() == ["addedCategory"] as Set
+	}
+
+	def "categories should not be modifiable by a client directly"(){
+
+		when:
+			def node = new DiffNode(null, Mock(Accessor), Object)
+			def cats = node.getCategories()
+			cats.removeAll()
+		then :
+			thrown UnsupportedOperationException
+	}
+
+	def "should throw exception when added a null collection"(){
+
+		when:
+			def node = new DiffNode(null, Mock(Accessor), Object)
+			node.addCategories(null)
+		then :
+			def ex = thrown(IllegalArgumentException)
+			ex.message == "'additionalCategories' must not be null"
+	}
 }