Assigning a value via DiffNode now creates missing parent objects

As it turns out, the DiffNode#canonicalSet method always expected all
parent objects of the node to already exist in the target object, in
order to assign the value. If those objects were missing, it simply
didn't do anything.

The problem has been fixed by allowing certain DiffNodes to create
instances of their respective object types. By default this happens by
invoking the types public non-arg constructor. If this fails, an
exception will be thrown. To add support for other types, I added a
mechanism to provide a custom InstanceFactory, which can be used to
add support for types, that don't qualify for the dafault behavior.

[Fixes #115]

Author: SQiShER

CHANGELOG.md

@@ -7,12 +7,17 @@
   specific object types.
 - **Inclusion:** Implemented a mechanism to register custom inclusion resolvers to 
   support inclusion rules far beyond the built-in ones.
+- **Introspection:** Implemented a mechanism to register a custom instance factory, 
+  which will be used by `DiffNode#canonicalSet` in order to create instances of missing 
+  objects 
 
 ### Improvements
 - **Inclusion:** Performance improvements (via @Deipher)
+- **DiffNode:** `canonicalSet` now automatically creates missing objects along the 
+  path to the root object 
 
 ### Bugfixes
 - **Circular Reference Detection:** Fixed 'Detected inconsistency in 
   enter/leave sequence. Must always be LIFO.' bug that could occur 
   due to inconsistent cleanup of the instance memory when a circular
-  reference has been detected.
+  reference has been detected.

src/integration-test/java/de/danielbechler/diff/issues/issue115/ObjectMergerIT.groovy

@@ -0,0 +1,67 @@
+/*
+ * 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.issues.issue115
+
+import de.danielbechler.diff.ObjectMerger
+import groovy.transform.ToString
+import spock.lang.Issue
+import spock.lang.Specification
+import spock.lang.Subject
+
+@Issue('https://github.com/SQiShER/java-object-diff/issues/115')
+@Subject(ObjectMerger)
+class ObjectMergerIT extends Specification {
+
+	def 'should write changes to delta object and create missing parent objects along the way'() {
+		given:
+		  A base = new A();
+		  base.b = new B();
+		  base.b.y = 10;
+		  base.x = 10;
+
+		and:
+		  A change = new A();
+		  change.b = new B();
+		  change.b.y = 12;
+		  change.x = 10;
+
+
+		when:
+		  def objectMerger = new ObjectMerger()
+		  def delta = new A()
+		  objectMerger.merge(change, base, delta);
+
+		then:
+		  delta.b instanceof B
+		  delta.b.y == 12
+	}
+
+	@ToString
+	public static class A {
+		int x
+		B b
+
+		public A() {}
+	}
+
+	@ToString
+	public static class B {
+		int y
+
+		public B() {}
+	}
+}

src/integration-test/java/de/danielbechler/diff/node/DiffNodeIT.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.node
+
+import de.danielbechler.diff.ObjectDifferBuilder
+import de.danielbechler.diff.introspection.InstanceFactory
+import de.danielbechler.diff.introspection.TypeInstantiationException
+import de.danielbechler.diff.path.NodePath
+import spock.lang.Specification
+import spock.lang.Subject
+
+@Subject(DiffNode)
+class DiffNodeIT extends Specification {
+
+	def 'canonicalSet() should create missing objects along the path'() {
+		given:
+		  def base = new A(b: new B(c: new C(d: new D(x: 'to-be-changed'))))
+		  def working = new A(b: new B(c: new C(d: new D(x: 'changed'))))
+
+		and:
+		  def instanceFactory = new InstanceFactory() {
+			  Object newInstanceOfType(Class<?> type) {
+				  if (type.isAssignableFrom(C)) {
+					  return C.newInstance()
+				  }
+				  return null
+			  }
+		  }
+
+		when:
+		  def target = new A()
+		  def node = ObjectDifferBuilder.startBuilding()
+				  .introspection()
+				  .setInstanceFactory(instanceFactory)
+				  .and()
+				  .build()
+				  .compare(working, base)
+		  node.getChild(NodePath.with('b', 'c', 'd', 'x')).canonicalSet(target, 'yay')
+
+		then:
+		  target.b instanceof B
+		  target.b.c instanceof C
+		  target.b.c.d instanceof D
+		  target.b.c.d.x == 'yay'
+	}
+
+	def 'canonicalSet() should throw exception when missing object along the path cannot be instantiated'() {
+		given:
+		  def base = new A(b: new B(c: new C(d: new D(x: 'to-be-changed'))))
+		  def working = new A(b: new B(c: new C(d: new D(x: 'changed'))))
+
+		when:
+		  def target = new A()
+		  def node = ObjectDifferBuilder.buildDefault().compare(working, base)
+		  node.getChild(NodePath.with('b', 'c', 'd', 'x')).canonicalSet(target, 'yay')
+
+		then:
+		  TypeInstantiationException exception = thrown(TypeInstantiationException)
+		  exception.type == C
+		  exception.reason == "Type doesn't have a public non-arg constructur"
+		  exception.message == "Failed to create instance of type '" + exception.type + "'. Reason: " + exception.reason
+	}
+
+	public static class A {
+		B b
+	}
+
+	public static class B {
+		C c
+	}
+
+	public static class C {
+		D d
+
+		private C() {
+		}
+
+		public static C newInstance() {
+			return new C()
+		}
+	}
+
+	public static class D {
+		def x
+	}
+}

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

@@ -21,17 +21,17 @@
 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,
+		IsIntrospectableResolver,
 		IsIgnoredResolver,
 		IsReturnableResolver,
-		ComparisonStrategyResolver, PrimitiveDefaultValueModeResolver
+		ComparisonStrategyResolver,
+		PrimitiveDefaultValueModeResolver
 {
 }

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

@@ -38,7 +38,6 @@
 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;
@@ -170,11 +169,6 @@ 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);

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

@@ -21,10 +21,9 @@
 import de.danielbechler.diff.comparison.ComparisonStrategy;
 import de.danielbechler.diff.comparison.ComparisonStrategyResolver;
 import de.danielbechler.diff.filtering.IsReturnableResolver;
-import de.danielbechler.diff.introspection.Introspector;
-import de.danielbechler.diff.introspection.IntrospectorResolver;
 import de.danielbechler.diff.introspection.IsIntrospectableResolver;
 import de.danielbechler.diff.introspection.TypeInfo;
+import de.danielbechler.diff.introspection.TypeInfoResolver;
 import de.danielbechler.diff.node.DiffNode;
 import de.danielbechler.util.Assert;
 
@@ -39,14 +38,14 @@ public final class BeanDiffer implements Differ
 	private final IsIntrospectableResolver isIntrospectableResolver;
 	private final IsReturnableResolver isReturnableResolver;
 	private final ComparisonStrategyResolver comparisonStrategyResolver;
-	private final IntrospectorResolver introspectorResolver;
 	private final DifferDispatcher differDispatcher;
+	private final TypeInfoResolver typeInfoResolver;
 
 	public BeanDiffer(final DifferDispatcher differDispatcher,
 					  final IsIntrospectableResolver introspectableResolver,
 					  final IsReturnableResolver returnableResolver,
 					  final ComparisonStrategyResolver comparisonStrategyResolver,
-					  final IntrospectorResolver introspectorResolver)
+					  final TypeInfoResolver typeInfoResolver)
 	{
 		Assert.notNull(differDispatcher, "differDispatcher");
 		this.differDispatcher = differDispatcher;
@@ -60,8 +59,8 @@ public BeanDiffer(final DifferDispatcher differDispatcher,
 		Assert.notNull(comparisonStrategyResolver, "comparisonStrategyResolver");
 		this.comparisonStrategyResolver = comparisonStrategyResolver;
 
-		Assert.notNull(introspectorResolver, "introspectorResolver");
-		this.introspectorResolver = introspectorResolver;
+		Assert.notNull(typeInfoResolver, "typeInfoResolver");
+		this.typeInfoResolver = typeInfoResolver;
 	}
 
 	public boolean accepts(final Class<?> type)
@@ -108,9 +107,7 @@ else if (isIntrospectableResolver.isIntrospectable(beanNode))
 
 	private void compareUsingIntrospection(final DiffNode beanNode, final Instances beanInstances)
 	{
-		final Class<?> beanType = beanInstances.getType();
-		final Introspector introspector = introspectorResolver.introspectorForNode(beanNode);
-		final TypeInfo typeInfo = introspector.introspect(beanType);
+		final TypeInfo typeInfo = typeInfoResolver.typeInfoForNode(beanNode);
 		beanNode.setValueTypeInfo(typeInfo);
 		for (final PropertyAwareAccessor propertyAccessor : typeInfo.getAccessors())
 		{

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

@@ -0,0 +1,41 @@
+/*
+ * 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;
+
+/**
+ * Serves as factory for objects. It is mainly used when {@link de.danielbechler.diff.node.DiffNode#canonicalSet(Object,
+ * Object)} is called on a node for which the target returns <code>null</code> for its parent. The parent (and
+ * subsequently all of its predecessors along the path) will be created via this factory and inserted into the target
+ * object.
+ */
+public interface InstanceFactory
+{
+	/**
+	 * @param type The type for which a new instance should be created
+	 * @return A new instance of the given <code>type</code> or <code>null</code> if it doesn't know how to instantiate
+	 * the type. In case of the latter, the {@link de.danielbechler.diff.ObjectDiffer} will automatically fallback to
+	 * instantiation via public non-arg constructor. If that also fails, an {@link de.danielbechler.diff.introspection.TypeInstantiationException}
+	 * will be thrown.
+	 * <p/>
+	 * <b>Note from the author:</b> it wasn't an easy decision, but in the end I favored an exception over
+	 * logging a warning, because this way it is much harder to accidentally end up with incomplete merges without
+	 * noticing. If this turns out to be a problem for you, please let me know in the issue tracker. We could probably
+	 * add a flag to switch to the logging-only mode. But as long as nobody complains, I'll just leave it as it is right
+	 * now.
+	 */
+	Object newInstanceOfType(Class<?> type);
+}

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

@@ -0,0 +1,44 @@
+/*
+ * 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.util.Assert;
+
+class InstanceFactoryFallbackDecorator implements InstanceFactory
+{
+	private final InstanceFactory fallbackInstanceFactory = new PublicNoArgsConstructorInstanceFactory();
+	private final InstanceFactory instanceFactory;
+
+	InstanceFactoryFallbackDecorator(final InstanceFactory instanceFactory)
+	{
+		Assert.notNull(instanceFactory, "instanceFactory");
+		this.instanceFactory = instanceFactory;
+	}
+
+	public Object newInstanceOfType(final Class<?> type)
+	{
+		final Object instance = instanceFactory.newInstanceOfType(type);
+		if (instance != null)
+		{
+			return instance;
+		}
+		else
+		{
+			return fallbackInstanceFactory.newInstanceOfType(type);
+		}
+	}
+}

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

@@ -31,6 +31,22 @@
  */
 public interface IntrospectionConfigurer
 {
+	/**
+	 * When assigning new values via {@link de.danielbechler.diff.node.DiffNode} (e.g. during merging) it will
+	 * implicitly create missing instances of its parent objects along the path to the root object. By default those
+	 * instances will be created via public non-arg constructor. If that fails a {@link
+	 * de.danielbechler.diff.introspection.TypeInstantiationException} will be thrown.
+	 * <p/>
+	 * To add support for types that need to be instantiated differently you can overide the default behavior via
+	 * custom {@link de.danielbechler.diff.introspection.InstanceFactory}. When doing so, don't worry about types
+	 * actually that are suitable for the default behavior, as it will automatically kick in, whenever the custom
+	 * factroy returns {@code null}.
+	 *
+	 * @param instanceFactory A custom instance factory
+	 * @throws java.lang.IllegalArgumentException when the instanceFactory is null
+	 */
+	IntrospectionConfigurer setInstanceFactory(InstanceFactory instanceFactory);
+
 	IntrospectionConfigurer setDefaultIntrospector(Introspector introspector);
 
 	Of ofType(Class<?> type);