Fixed #99: Allow Differs to be easily registered via ObjectDifferBuilder

Author: SQiShER

src/integration-test/java/de/danielbechler/diff/ObjectDifferBuilderIT.groovy

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2014 Daniel Bechler
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package de.danielbechler.diff
+
+import de.danielbechler.diff.differ.Differ
+import de.danielbechler.diff.differ.DifferDispatcher
+import de.danielbechler.diff.differ.DifferFactory
+import spock.lang.Specification
+
+/**
+ * Created by Daniel Bechler.
+ */
+@SuppressWarnings("GroovyAssignabilityCheck")
+class ObjectDifferBuilderIT extends Specification {
+	def differMock = Mock(Differ)
+
+	def 'Register a DifferExtension'() {
+		given:
+		  def differFactory = new DifferFactory() {
+			  @Override
+			  Differ createDiffer(DifferDispatcher differDispatcher, NodeQueryService nodeQueryService) {
+				  return differMock
+			  }
+		  }
+		  def objectDiffer = ObjectDifferBuilder.startBuilding()
+				  .differs().register(differFactory)
+				  .build()
+
+		when:
+		  objectDiffer.compare("foo", "bar")
+
+		then:
+		  1 * differMock.accepts(*_) >> true
+
+		and:
+		  1 * differMock.compare(*_)
+	}
+}

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

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2014 Daniel Bechler
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package de.danielbechler.diff;
+
+import de.danielbechler.diff.category.CategoryResolver;
+import de.danielbechler.diff.comparison.ComparisonStrategyResolver;
+import de.danielbechler.diff.comparison.PrimitiveDefaultValueModeResolver;
+import de.danielbechler.diff.filtering.IsReturnableResolver;
+import de.danielbechler.diff.inclusion.IsIgnoredResolver;
+import de.danielbechler.diff.introspection.IntrospectorResolver;
+import de.danielbechler.diff.introspection.IsIntrospectableResolver;
+
+/**
+ * Created by Daniel Bechler.
+ */
+public interface NodeQueryService extends
+		CategoryResolver,
+		IntrospectorResolver, IsIntrospectableResolver,
+		IsIgnoredResolver,
+		IsReturnableResolver,
+		ComparisonStrategyResolver, PrimitiveDefaultValueModeResolver
+{
+}

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

@@ -22,9 +22,13 @@
 import de.danielbechler.diff.circular.CircularReferenceService;
 import de.danielbechler.diff.comparison.ComparisonConfigurer;
 import de.danielbechler.diff.comparison.ComparisonService;
+import de.danielbechler.diff.comparison.ComparisonStrategy;
+import de.danielbechler.diff.comparison.PrimitiveDefaultValueMode;
 import de.danielbechler.diff.differ.BeanDiffer;
 import de.danielbechler.diff.differ.CollectionDiffer;
+import de.danielbechler.diff.differ.DifferConfigurer;
 import de.danielbechler.diff.differ.DifferDispatcher;
+import de.danielbechler.diff.differ.DifferFactory;
 import de.danielbechler.diff.differ.DifferProvider;
 import de.danielbechler.diff.differ.MapDiffer;
 import de.danielbechler.diff.differ.PrimitiveDiffer;
@@ -34,6 +38,12 @@
 import de.danielbechler.diff.inclusion.InclusionService;
 import de.danielbechler.diff.introspection.IntrospectionConfigurer;
 import de.danielbechler.diff.introspection.IntrospectionService;
+import de.danielbechler.diff.introspection.Introspector;
+import de.danielbechler.diff.node.DiffNode;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Set;
 
 /**
  * This is the entry point of every diffing operation. It acts as a factory to get hold of an actual {@link
@@ -50,6 +60,9 @@ public class ObjectDifferBuilder
 	private final ComparisonService comparisonService = new ComparisonService(this);
 	private final ReturnableNodeService returnableNodeService = new ReturnableNodeService(this);
 	private final CircularReferenceService circularReferenceService = new CircularReferenceService(this);
+	private final DifferConfigurer differConfigurer = new DifferConfigurerImpl();
+	private final NodeQueryService nodeQueryService = new NodeQueryServiceImpl();
+	private final Collection<DifferFactory> differFactories = new ArrayList<DifferFactory>();
 
 	private ObjectDifferBuilder()
 	{
@@ -63,11 +76,20 @@ public static ObjectDiffer buildDefault()
 	public ObjectDiffer build()
 	{
 		final DifferProvider differProvider = new DifferProvider();
-		final DifferDispatcher differDispatcher = new DifferDispatcher(differProvider, circularReferenceService, circularReferenceService, inclusionService, returnableNodeService);
+		final DifferDispatcher differDispatcher = new DifferDispatcher(
+				differProvider,
+				circularReferenceService,
+				circularReferenceService,
+				inclusionService,
+				returnableNodeService);
 		differProvider.push(new BeanDiffer(differDispatcher, introspectionService, returnableNodeService, comparisonService, introspectionService));
 		differProvider.push(new CollectionDiffer(differDispatcher, comparisonService));
 		differProvider.push(new MapDiffer(differDispatcher, comparisonService));
 		differProvider.push(new PrimitiveDiffer(comparisonService));
+		for (final DifferFactory differFactory : differFactories)
+		{
+			differProvider.push(differFactory.createDiffer(differDispatcher, nodeQueryService));
+		}
 		return new ObjectDiffer(differDispatcher);
 	}
 
@@ -125,4 +147,57 @@ public CategoryConfigurer categories()
 	{
 		return categoryService;
 	}
+
+	public DifferConfigurer differs()
+	{
+		return differConfigurer;
+	}
+
+	public class DifferConfigurerImpl implements DifferConfigurer
+	{
+		public ObjectDifferBuilder register(final DifferFactory differFactory)
+		{
+			differFactories.add(differFactory);
+			return ObjectDifferBuilder.this;
+		}
+
+	}
+
+	private class NodeQueryServiceImpl implements NodeQueryService
+	{
+		public Set<String> resolveCategories(final DiffNode node)
+		{
+			return categoryService.resolveCategories(node);
+		}
+
+		public Introspector introspectorForNode(final DiffNode node)
+		{
+			return introspectionService.introspectorForNode(node);
+		}
+
+		public boolean isIntrospectable(final DiffNode node)
+		{
+			return introspectionService.isIntrospectable(node);
+		}
+
+		public boolean isIgnored(final DiffNode node)
+		{
+			return inclusionService.isIgnored(node);
+		}
+
+		public boolean isReturnable(final DiffNode node)
+		{
+			return returnableNodeService.isReturnable(node);
+		}
+
+		public ComparisonStrategy resolveComparisonStrategy(final DiffNode node)
+		{
+			return comparisonService.resolveComparisonStrategy(node);
+		}
+
+		public PrimitiveDefaultValueMode resolvePrimitiveDefaultValueMode(final DiffNode node)
+		{
+			return comparisonService.resolvePrimitiveDefaultValueMode(node);
+		}
+	}
 }

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

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2014 Daniel Bechler
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package de.danielbechler.diff.differ;
+
+import de.danielbechler.diff.ObjectDifferBuilder;
+
+/**
+ * Created by Daniel Bechler.
+ */
+public interface DifferConfigurer
+{
+	/**
+	 * Registers a new Differ to be used when comparing objects. Differs that have been registered later always win
+	 * over earlier Differs. This way it is easily possible to override the default behavior, without actually removing
+	 * the standard differs.
+	 *
+	 * @param differFactory Factory that creates a new Differ. Will be called exactly once and the resulting Differ
+	 *                      will be pushed to the underlying {@link de.danielbechler.diff.differ.DifferProvider}.
+	 * @return The {@link de.danielbechler.diff.ObjectDifferBuilder} for chaining.
+	 */
+	ObjectDifferBuilder register(DifferFactory differFactory);
+}

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

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2014 Daniel Bechler
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package de.danielbechler.diff.differ;
+
+import de.danielbechler.diff.NodeQueryService;
+
+/**
+ * Created by Daniel Bechler.
+ */
+public interface DifferFactory
+{
+	Differ createDiffer(DifferDispatcher differDispatcher, NodeQueryService nodeQueryService);
+}