Merge branch 'circular-references'

Author: SQiShER

NOTICE

@@ -17,6 +17,8 @@ under the License.
 
 This project includes:
   SLF4J - MIT License
+  Logback - EPL v1.0 / LGPL 2.1 License
   Mockito - MIT License
   JUnit - BSD License
   Hamcrest - BSD License
+  Fest Assertions = Apache 2.0 License

pom.xml

@@ -15,13 +15,14 @@
   ~ limitations under the License.
   -->
 
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 
 	<modelVersion>4.0.0</modelVersion>
 	<groupId>de.danielbechler</groupId>
 	<artifactId>java-object-diff</artifactId>
 	<name>Java Object Diff</name>
-	<version>0.8.3-SNAPSHOT</version>
+	<version>0.9-SNAPSHOT</version>
 
 	<developers>
 		<developer>
@@ -78,7 +79,7 @@
 			<plugin>
 				<artifactId>maven-release-plugin</artifactId>
 				<configuration>
-					<scmCommentPrefix />
+					<scmCommentPrefix/>
 				</configuration>
 			</plugin>
 			<plugin>
@@ -140,6 +141,24 @@
 			<version>1.9.0</version>
 			<scope>test</scope>
 		</dependency>
+		<dependency>
+			<groupId>ch.qos.logback</groupId>
+			<artifactId>logback-core</artifactId>
+			<version>1.0.3</version>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>ch.qos.logback</groupId>
+			<artifactId>logback-classic</artifactId>
+			<version>1.0.3</version>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.easytesting</groupId>
+			<artifactId>fest-assert-core</artifactId>
+			<version>2.0M6</version>
+			<scope>test</scope>
+		</dependency>
 	</dependencies>
 
 	<distributionManagement>

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

@@ -16,11 +16,19 @@
 
 package de.danielbechler.diff;
 
+import de.danielbechler.diff.node.*;
 import de.danielbechler.util.*;
 
 /** @author Daniel Bechler */
-abstract class AbstractDiffer implements Differ, Configurable
+abstract class AbstractDiffer<T extends Node> implements Differ<T>, Configurable
 {
+	static final ThreadLocal<CircularReferenceDetector> CIRCULAR_REFERENCE_DETECTOR_THREAD_LOCAL;
+
+	static
+	{
+		CIRCULAR_REFERENCE_DETECTOR_THREAD_LOCAL = new CircularReferenceDetectorThreadLocal();
+	}
+
 	private DelegatingObjectDiffer delegate;
 
 	protected AbstractDiffer()
@@ -33,6 +41,41 @@ protected AbstractDiffer(final DelegatingObjectDiffer delegate)
 		this.delegate = delegate;
 	}
 
+	@Override
+	public final T compare(final Node parentNode, final Instances instances)
+	{
+		final Object working = instances.getWorking();
+		final CircularReferenceDetector circularReferenceDetector = CIRCULAR_REFERENCE_DETECTOR_THREAD_LOCAL.get();
+		final boolean destroyOnReturn = circularReferenceDetector.isNew();
+		T node;
+		try
+		{
+			circularReferenceDetector.push(working);
+			try
+			{
+				node = internalCompare(parentNode, instances);
+			}
+			finally
+			{
+				circularReferenceDetector.remove(working);
+			}
+		}
+		catch (CircularReferenceDetector.CircularReferenceException e)
+		{
+			node = newNode(parentNode, instances);
+			node.setState(Node.State.CIRCULAR);
+		}
+		if (destroyOnReturn)
+		{
+			CIRCULAR_REFERENCE_DETECTOR_THREAD_LOCAL.remove();
+		}
+		return node;
+	}
+
+	protected abstract T internalCompare(Node parentNode, Instances instances);
+
+	protected abstract T newNode(Node parentNode, Instances instances);
+
 	public final DelegatingObjectDiffer getDelegate()
 	{
 		return delegate;
@@ -48,4 +91,13 @@ public final Configuration getConfiguration()
 	{
 		return delegate.getConfiguration();
 	}
+
+	private static final class CircularReferenceDetectorThreadLocal extends ThreadLocal<CircularReferenceDetector>
+	{
+		@Override
+		protected CircularReferenceDetector initialValue()
+		{
+			return new CircularReferenceDetector();
+		}
+	}
 }

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

@@ -22,11 +22,12 @@
 import de.danielbechler.util.*;
 
 /**
- * Used to find differences between objects that were not handled by one of the other (specialized) {@link Differ Differs}.
+ * Used to find differences between objects that were not handled by one of the other (specialized) {@link
+ * Differ Differs}.
  *
  * @author Daniel Bechler
  */
-final class BeanDiffer extends AbstractDiffer
+final class BeanDiffer extends AbstractDiffer<Node>
 {
 	private Introspector introspector = new StandardIntrospector();
 
@@ -51,9 +52,10 @@ Node compare(final Object working, final Object base)
 		return compare(Node.ROOT, Instances.of(new RootAccessor(), working, base));
 	}
 
-	public Node compare(final Node parentNode, final Instances instances)
+	@Override
+	protected Node internalCompare(final Node parentNode, final Instances instances)
 	{
-		final Node node = new DefaultNode(parentNode, instances.getSourceAccessor(), instances.getType());
+		final Node node = newNode(parentNode, instances);
 		if (getDelegate().isIgnored(node))
 		{
 			node.setState(Node.State.IGNORED);
@@ -69,9 +71,15 @@ else if (instances.getType() == null)
 		return node;
 	}
 
+	@Override
+	protected Node newNode(final Node parentNode, final Instances instances)
+	{
+		return new DefaultNode(parentNode, instances.getSourceAccessor(), instances.getType());
+	}
+
 	private Node compareBean(final Node parentNode, final Instances instances)
 	{
-		final Node node = new DefaultNode(parentNode, instances.getSourceAccessor(), instances.getType());
+		final Node node = newNode(parentNode, instances);
 		if (instances.hasBeenAdded())
 		{
 			node.setState(Node.State.ADDED);

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

@@ -0,0 +1,101 @@
+/*
+ * Copyright 2012 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 java.util.*;
+
+/** @author Daniel Bechler */
+final class CircularReferenceDetector
+{
+	private final Deque<Object> stack = new LinkedList<Object>();
+
+	private boolean isNew = true;
+
+	public CircularReferenceDetector()
+	{
+	}
+
+	public boolean isNew()
+	{
+		return isNew;
+	}
+
+	public void push(final Object instance)
+	{
+		if (instance == null)
+		{
+			return;
+		}
+		if (isNew)
+		{
+			isNew = false;
+		}
+		if (knows(instance))
+		{
+			throw new CircularReferenceException();
+		}
+		stack.addLast(instance);
+	}
+
+	public boolean knows(final Object needle)
+	{
+		for (final Object object : stack)
+		{
+			if (object == needle)
+			{
+				return true;
+			}
+		}
+		return false;
+	}
+
+	public void remove(final Object instance)
+	{
+		if (instance == null)
+		{
+			return;
+		}
+		if (stack.getLast() == instance)
+		{
+			stack.removeLast();
+		}
+		else
+		{
+			throw new IllegalArgumentException("Detected inconsistency in enter/leave sequence. Must always be LIFO.");
+		}
+	}
+
+	public int size()
+	{
+		return stack.size();
+	}
+
+	public static class CircularReferenceException extends RuntimeException
+	{
+		private static final long serialVersionUID = 1L;
+
+		public CircularReferenceException()
+		{
+		}
+
+		@Override
+		public Throwable fillInStackTrace()
+		{
+			return null;
+		}
+	}
+}

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

@@ -27,7 +27,7 @@
  *
  * @author Daniel Bechler
  */
-final class CollectionDiffer extends AbstractDiffer
+final class CollectionDiffer extends AbstractDiffer<CollectionNode>
 {
 	public CollectionDiffer()
 	{
@@ -44,7 +44,8 @@ public CollectionNode compare(final Collection<?> working, final Collection<?> b
 		return compare(Node.ROOT, Instances.of(new RootAccessor(), working, base));
 	}
 
-	public CollectionNode compare(final Node parentNode, final Instances instances)
+	@Override
+	protected CollectionNode internalCompare(final Node parentNode, final Instances instances)
 	{
 		final CollectionNode node = new CollectionNode(parentNode, instances.getSourceAccessor(), instances.getType());
 		if (getDelegate().isIgnored(node))
@@ -74,7 +75,15 @@ else if (instances.areSame())
 		return node;
 	}
 
-	private void handleItems(final CollectionNode collectionNode, final Instances instances, final Iterable<?> items)
+	@Override
+	protected CollectionNode newNode(final Node parentNode, final Instances instances)
+	{
+		return new CollectionNode(parentNode, instances.getSourceAccessor(), instances.getType());
+	}
+
+	private void handleItems(final CollectionNode collectionNode,
+							 final Instances instances,
+							 final Iterable<?> items)
 	{
 		for (final Object item : items)
 		{
@@ -91,7 +100,9 @@ else if (getConfiguration().isReturnable(child))
 		}
 	}
 
-	private Node compareItem(final CollectionNode collectionNode, final Instances instances, final Object item)
+	private Node compareItem(final CollectionNode collectionNode,
+							 final Instances instances,
+							 final Object item)
 	{
 		final Accessor accessor = collectionNode.accessorForItem(item);
 		return getDelegate().delegate(collectionNode, instances.access(accessor));

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

@@ -34,6 +34,7 @@ public class Configuration implements NodeInspector
 	private final Collection<Class<?>> equalsOnlyTypes = new LinkedHashSet<Class<?>>(10);
 	private boolean returnUnchangedNodes = false;
 	private boolean returnIgnoredNodes = false;
+	private boolean returnCircularNodes = true;
 
 	public Configuration withCategory(final String category)
 	{
@@ -95,6 +96,18 @@ public Configuration withoutUntouchedNodes()
 		return this;
 	}
 
+	public Configuration withCircularNodes()
+	{
+		this.returnCircularNodes = true;
+		return this;
+	}
+
+	public Configuration withoutCircularNodes()
+	{
+		this.returnCircularNodes = false;
+		return this;
+	}
+
 	@Override
 	public boolean isIgnored(final Node node)
 	{
@@ -170,14 +183,18 @@ public boolean isEqualsOnly(final Node node)
 	@Override
 	public boolean isReturnable(final Node node)
 	{
-		if (node.getState() == Node.State.UNTOUCHED)
+		if (node.isUntouched())
 		{
 			return returnUnchangedNodes;
 		}
-		else if (node.getState() == Node.State.IGNORED)
+		else if (node.isIgnored())
 		{
 			return returnIgnoredNodes;
 		}
+		else if (node.isCircular())
+		{
+			return returnCircularNodes;
+		}
 		return true;
 	}
 }

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

@@ -19,7 +19,7 @@
 import de.danielbechler.diff.node.*;
 
 /** @author Daniel Bechler */
-public interface Differ
+interface Differ<T extends Node>
 {
-	Node compare(Node parentNode, Instances instances);
+	T compare(Node parentNode, Instances instances);
 }