Added categories from configuration to DiffNode on comparison.

Added DiffNode.addCategories(Collection<String> categories)
so users can add their own categories while traversing nodes.
Made DiffNode.getCategories return an UnmodifiableSet to discourage
users from editing the returned Set.
Implemented unit tests for categories manipulation in DiffNodeTest.
Added CategoriesTestIT integration test for categories resolution.

Author: scompo

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

@@ -0,0 +1,45 @@
+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 "should return all categories"(){
+		setup:
+			def obj1 = new MyObject("aaa","aaa")
+			def obj2 =  new MyObject("bbb","bbb")
+			def differ = ObjectDifferBuilder.startBuilding()
+					.categories()
+					.ofNode(NodePath.with("firstString")).toBe("cat1")
+					.ofNode(NodePath.with("secondString")).toBe("cat1")
+					.and()
+					.build()
+			def node = differ.compare(obj1,obj2)
+
+		expect :
+			node.getChild("firstString").getCategories() == ["cat1"] as Set
+			node.getChild("secondString").getCategories() == ["cat1", "catAnnotation"] as Set
+	}
+
+	class MyObject{
+
+		def firstString
+        def secondString
+
+		MyObject(firstString,secondString) {
+
+			this.firstString = firstString
+			this.secondString = secondString
+		}
+
+        @ObjectDiffProperty(categories = ["catAnnotation"])
+		def getSecondString() {
+			return secondString
+		}
+	}
+}

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

@@ -279,4 +279,5 @@ public ObjectDifferBuilder and()
 	{
 		return rootConfiguration;
 	}
+
 }

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

@@ -38,6 +38,7 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeSet;
+import java.util.Collection;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import static java.util.Collections.unmodifiableSet;
@@ -67,6 +68,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 +575,11 @@ public boolean isExcluded()
 		return false;
 	}
 
-	// TODO These categories should also contain the ones configured via CategoryService
+	/**
+	 * Returns an unmodifiable {@link java.util.Set} of {@link java.lang.String} with the categories of this node.
+	 *
+	 * @return an unmodifiable {@link java.util.Set} of {@link java.lang.String} with the categories of this node
+     */
 	public final Set<String> getCategories()
 	{
 		final Set<String> categories = new TreeSet<String>();
@@ -589,7 +595,9 @@ public final Set<String> getCategories()
 				categories.addAll(categoriesFromAccessor);
 			}
 		}
-		return categories;
+		categories.addAll(additionalCategories);
+
+		return unmodifiableSet(categories);
 	}
 
 	/**
@@ -732,6 +740,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 added categories"(){
+		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"
+	}
 }