Reimplemented property access exception handling

I removed the write exception handler method from the exception handler
interface because it could only be triggered when DiffNode#canonicalSet
or DiffNode#set get explicitly invoked by the user of the library.

But at that point the exception could simply be caught and handled
directly, so the indirection via exception handler seems unneccessary.

[Fixes #116]

Author: SQiShER

CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.91.1
+
+### Features
+- **Exception Handling:** Reimplemented property access exception handling
+
 ## 0.91
 
 ### Features

src/integration-test/java/de/danielbechler/diff/introspection/HandlingPropertyAccessExceptionsAT.groovy

@@ -0,0 +1,100 @@
+/*
+ * 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.introspection
+
+import de.danielbechler.diff.ObjectDifferBuilder
+import de.danielbechler.diff.node.DiffNode
+import de.danielbechler.diff.path.NodePath
+import spock.lang.Specification
+import spock.lang.Subject
+
+@Subject(PropertyAccessExceptionHandler)
+class HandlingPropertyAccessExceptionsAT extends Specification {
+
+	def exceptionHandler = Mock(PropertyAccessExceptionHandler)
+	def objectDiffer = ObjectDifferBuilder
+			.startBuilding()
+			.introspection()
+			.handlePropertyAccessExceptionsUsing(exceptionHandler)
+			.and().build()
+
+	@SuppressWarnings("GroovyAssignabilityCheck")
+	def 'exceptions that occur when accessing getters can be handled via PropertyAccessExceptionHandler'() {
+		given:
+		  def working = new StubForPropertyAccessExceptionTesting(value: 'foo', exceptionOnRead: true)
+		  def base = new StubForPropertyAccessExceptionTesting(value: 'bar', exceptionOnRead: true)
+
+		when:
+		  objectDiffer.compare(working, base)
+
+		then:
+		  1 * exceptionHandler.onPropertyReadException(_ as PropertyReadException, _ as DiffNode) >> {
+			  PropertyReadException exception = it[0]
+			  assert exception.message == "Failed to read value from property 'value' of type " +
+					  "'de.danielbechler.diff.introspection.HandlingPropertyAccessExceptionsAT.StubForPropertyAccessExceptionTesting'"
+			  assert exception.targetType == StubForPropertyAccessExceptionTesting
+			  assert exception.propertyName == 'value'
+
+			  DiffNode node = it[1]
+			  assert node.propertyName == 'value'
+			  assert node.path.matches(NodePath.with('value'))
+			  assert node.state == DiffNode.State.INACCESSIBLE
+		  }
+	}
+
+	def 'exceptions that occur when accessing setters can be handled by catching the thrown PropertyWriteException'() {
+		given:
+		  def working = new StubForPropertyAccessExceptionTesting(value: 'foo')
+		  def base = new StubForPropertyAccessExceptionTesting(value: 'bar')
+		  def diff = objectDiffer.compare(working, base)
+
+		expect:
+		  diff.getChild('value') != null
+
+		when:
+		  def target = new StubForPropertyAccessExceptionTesting(exceptionOnWrite: true)
+		  diff.getChild('value').canonicalSet(target, 'baz')
+
+		then:
+		  PropertyWriteException exception = thrown(PropertyWriteException)
+		  exception.newValue == 'baz'
+		  exception.message == "Failed to write new value 'baz' to property 'value' of type " +
+				  "'de.danielbechler.diff.introspection.HandlingPropertyAccessExceptionsAT.StubForPropertyAccessExceptionTesting'"
+		  exception.targetType == StubForPropertyAccessExceptionTesting
+		  exception.propertyName == 'value'
+	}
+
+	private static class StubForPropertyAccessExceptionTesting {
+		String value
+		def exceptionOnRead = false
+		def exceptionOnWrite = false
+
+		String getValue() {
+			if (exceptionOnRead) {
+				throw new RuntimeException()
+			}
+			return value;
+		}
+
+		void setValue(String value) {
+			if (exceptionOnWrite) {
+				throw new RuntimeException()
+			}
+			this.value = value
+		}
+	}
+}

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

@@ -80,7 +80,8 @@ public ObjectDiffer build()
 				circularReferenceService,
 				circularReferenceService,
 				inclusionService,
-				returnableNodeService);
+				returnableNodeService,
+				introspectionService);
 		differProvider.push(new BeanDiffer(differDispatcher, introspectionService, returnableNodeService, comparisonService, introspectionService));
 		differProvider.push(new CollectionDiffer(differDispatcher, comparisonService));
 		differProvider.push(new MapDiffer(differDispatcher, comparisonService));

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

@@ -18,11 +18,15 @@
 
 import de.danielbechler.diff.access.Accessor;
 import de.danielbechler.diff.access.Instances;
+import de.danielbechler.diff.access.PropertyAwareAccessor;
+import de.danielbechler.diff.introspection.PropertyReadException;
 import de.danielbechler.diff.circular.CircularReferenceDetector;
 import de.danielbechler.diff.circular.CircularReferenceDetectorFactory;
 import de.danielbechler.diff.circular.CircularReferenceExceptionHandler;
 import de.danielbechler.diff.filtering.IsReturnableResolver;
 import de.danielbechler.diff.inclusion.IsIgnoredResolver;
+import de.danielbechler.diff.introspection.PropertyAccessExceptionHandler;
+import de.danielbechler.diff.introspection.PropertyAccessExceptionHandlerResolver;
 import de.danielbechler.diff.node.DiffNode;
 import de.danielbechler.diff.path.NodePath;
 import de.danielbechler.diff.selector.ElementSelector;
@@ -43,14 +47,16 @@ public class DifferDispatcher
 	private final CircularReferenceExceptionHandler circularReferenceExceptionHandler;
 	private final IsIgnoredResolver isIgnoredResolver;
 	private final IsReturnableResolver isReturnableResolver;
+	private final PropertyAccessExceptionHandlerResolver propertyAccessExceptionHandlerResolver;
 	CircularReferenceDetector workingCircularReferenceDetector;
 	CircularReferenceDetector baseCircularReferenceDetector;
 
 	public DifferDispatcher(final DifferProvider differProvider,
 							final CircularReferenceDetectorFactory circularReferenceDetectorFactory,
 							final CircularReferenceExceptionHandler circularReferenceExceptionHandler,
 							final IsIgnoredResolver ignoredResolver,
-							final IsReturnableResolver returnableResolver)
+							final IsReturnableResolver returnableResolver,
+							final PropertyAccessExceptionHandlerResolver propertyAccessExceptionHandlerResolver)
 	{
 		Assert.notNull(differProvider, "differFactory");
 		this.differProvider = differProvider;
@@ -61,6 +67,7 @@ public DifferDispatcher(final DifferProvider differProvider,
 		this.circularReferenceDetectorFactory = circularReferenceDetectorFactory;
 		this.circularReferenceExceptionHandler = circularReferenceExceptionHandler;
 		this.isReturnableResolver = returnableResolver;
+		this.propertyAccessExceptionHandlerResolver = propertyAccessExceptionHandlerResolver;
 
 		resetInstanceMemory();
 	}
@@ -102,7 +109,33 @@ private DiffNode compare(final DiffNode parentNode,
 			return node;
 		}
 
-		final Instances accessedInstances = parentInstances.access(accessor);
+		final Instances accessedInstances;
+		if (accessor instanceof PropertyAwareAccessor)
+		{
+			final PropertyAwareAccessor propertyAwareAccessor = (PropertyAwareAccessor) accessor;
+			try
+			{
+				accessedInstances = parentInstances.access(accessor);
+			}
+			catch (final PropertyReadException e)
+			{
+				node.setState(DiffNode.State.INACCESSIBLE);
+				final Class<?> parentType = parentInstances.getType();
+				final String propertyName = propertyAwareAccessor.getPropertyName();
+				final PropertyAccessExceptionHandler exceptionHandler = propertyAccessExceptionHandlerResolver
+						.resolvePropertyAccessExceptionHandler(parentType, propertyName);
+				if (exceptionHandler != null)
+				{
+					exceptionHandler.onPropertyReadException(e, node);
+				}
+				return node;
+			}
+		}
+		else
+		{
+			accessedInstances = parentInstances.access(accessor);
+		}
+
 		if (accessedInstances.areNull())
 		{
 			return new DiffNode(parentNode, accessedInstances.getSourceAccessor(), accessedInstances.getType());

src/main/java/de/danielbechler/diff/filtering/ReturnableNodeService.java

@@ -41,6 +41,7 @@ public ReturnableNodeService(final ObjectDifferBuilder objectDifferBuilder)
 		this.objectDifferBuilder = objectDifferBuilder;
 		this.stateFilterSettings = new EnumMap<DiffNode.State, Boolean>(DiffNode.State.class);
 		this.stateFilterSettings.put(DiffNode.State.IGNORED, false);
+		this.stateFilterSettings.put(DiffNode.State.INACCESSIBLE, false);
 		this.stateFilterSettings.put(DiffNode.State.UNTOUCHED, false);
 		this.stateFilterSettings.put(DiffNode.State.CIRCULAR, true);
 		this.stateFilterSettings.put(DiffNode.State.ADDED, true);

src/main/java/de/danielbechler/diff/introspection/DefaultPropertyAccessExceptionHandler.java

@@ -17,20 +17,10 @@
 package de.danielbechler.diff.introspection;
 
 import de.danielbechler.diff.node.DiffNode;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 public class DefaultPropertyAccessExceptionHandler implements PropertyAccessExceptionHandler
 {
-	Logger logger = LoggerFactory.getLogger(DefaultPropertyAccessExceptionHandler.class);
-
-	public DiffNode onPropertyWriteException(final PropertyWriteException exception, final DiffNode node)
-	{
-		logger.info(exception.getMessage());
-		throw exception;
-	}
-
-	public DiffNode onPropertyReadException(final PropertyReadException exception, final DiffNode node)
+	public void onPropertyReadException(final PropertyReadException exception, final DiffNode node)
 	{
 		throw exception;
 	}

src/main/java/de/danielbechler/diff/introspection/IntrospectionConfigurer.java

@@ -50,6 +50,8 @@ public interface IntrospectionConfigurer
 
 	IntrospectionConfigurer setDefaultIntrospector(Introspector introspector);
 
+	IntrospectionConfigurer handlePropertyAccessExceptionsUsing(PropertyAccessExceptionHandler exceptionHandler);
+
 	Of ofType(Class<?> type);
 
 	Of ofNode(NodePath path);

src/main/java/de/danielbechler/diff/introspection/IntrospectionService.java

@@ -17,10 +17,10 @@
 package de.danielbechler.diff.introspection;
 
 import de.danielbechler.diff.ObjectDifferBuilder;
-import de.danielbechler.diff.instantiation.PublicNoArgsConstructorInstanceFactory;
-import de.danielbechler.diff.node.DiffNode;
 import de.danielbechler.diff.instantiation.InstanceFactory;
+import de.danielbechler.diff.instantiation.PublicNoArgsConstructorInstanceFactory;
 import de.danielbechler.diff.instantiation.TypeInfo;
+import de.danielbechler.diff.node.DiffNode;
 import de.danielbechler.diff.path.NodePath;
 import de.danielbechler.diff.path.NodePathValueHolder;
 import de.danielbechler.util.Assert;
@@ -32,7 +32,7 @@
 /**
  * @author Daniel Bechler
  */
-public class IntrospectionService implements IntrospectionConfigurer, IsIntrospectableResolver, TypeInfoResolver
+public class IntrospectionService implements IntrospectionConfigurer, IsIntrospectableResolver, TypeInfoResolver, PropertyAccessExceptionHandlerResolver
 {
 	private final Map<Class<?>, Introspector> typeIntrospectorMap = new HashMap<Class<?>, Introspector>();
 	private final Map<Class<?>, IntrospectionMode> typeIntrospectionModeMap = new HashMap<Class<?>, IntrospectionMode>();
@@ -41,6 +41,7 @@ public class IntrospectionService implements IntrospectionConfigurer, IsIntrospe
 	private final ObjectDifferBuilder objectDifferBuilder;
 	private Introspector defaultIntrospector = new StandardIntrospector();
 	private InstanceFactory instanceFactory = new PublicNoArgsConstructorInstanceFactory();
+	private PropertyAccessExceptionHandler defaultPropertyAccessExceptionHandler = new DefaultPropertyAccessExceptionHandler();
 
 	public IntrospectionService(final ObjectDifferBuilder objectDifferBuilder)
 	{
@@ -77,6 +78,11 @@ private static boolean isPrimitiveTypeEnumOrArray(final Class<?> nodeType)
 				|| nodeType.isArray();
 	}
 
+	public PropertyAccessExceptionHandler resolvePropertyAccessExceptionHandler(final Class<?> parentType, final String propertyName)
+	{
+		return defaultPropertyAccessExceptionHandler;
+	}
+
 	public TypeInfo typeInfoForNode(final DiffNode node)
 	{
 		final Class<?> beanType = node.getValueType();
@@ -117,6 +123,13 @@ public IntrospectionConfigurer setDefaultIntrospector(final Introspector introsp
 		return this;
 	}
 
+	public IntrospectionConfigurer handlePropertyAccessExceptionsUsing(final PropertyAccessExceptionHandler exceptionHandler)
+	{
+		Assert.notNull(exceptionHandler, "exceptionHandler");
+		defaultPropertyAccessExceptionHandler = exceptionHandler;
+		return this;
+	}
+
 	public Of ofType(final Class<?> type)
 	{
 		return new Of()

src/main/java/de/danielbechler/diff/introspection/PropertyAccessExceptionHandler.java

@@ -18,12 +18,13 @@
 
 import de.danielbechler.diff.node.DiffNode;
 
-/**
- * @author Daniel Bechler
- */
 public interface PropertyAccessExceptionHandler
 {
-	DiffNode onPropertyWriteException(PropertyWriteException exception, DiffNode node);
-
-	DiffNode onPropertyReadException(PropertyReadException exception, DiffNode node);
+	/**
+	 * Will be called whenever the value of a property could not be retrieved due to an underlying exception.
+	 *
+	 * @param exception This exception object contains more details about the property.
+	 * @param node      The {@link DiffNode} for which the exception occured.
+	 */
+	void onPropertyReadException(PropertyReadException exception, DiffNode node);
 }

src/main/java/de/danielbechler/diff/introspection/PropertyAccessExceptionHandlerResolver.java

@@ -0,0 +1,26 @@
+/*
+ * 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.introspection;
+
+public interface PropertyAccessExceptionHandlerResolver
+{
+	/**
+	 * @param parentType   The type of the object to which the property belongs.
+	 * @param propertyName The name of the property.
+	 */
+	PropertyAccessExceptionHandler resolvePropertyAccessExceptionHandler(Class<?> parentType, String propertyName);
+}