Skip to content

Commit 05654de

Browse files
SQiShERSQiShER
committed
Refactoring in progress
1 parent a6f824a commit 05654de

69 files changed

Lines changed: 4324 additions & 0 deletions

File tree

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

‎.gitignore‎

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,14 @@
11
*.class
22

3+
# IntelliJ IDEA #
4+
.idea
5+
*.ipr
6+
*.iml
7+
*.iws
8+
9+
# Maven Generated Files #
10+
target
11+
312
# Package Files #
413
*.jar
514
*.war

‎pom.xml‎

Lines changed: 33 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,33 @@
1+
<?xml version="1.0" encoding="UTF-8"?>
2+
<project xmlns="http://maven.apache.org/POM/4.0.0"
3+
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4+
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
5+
6+
<modelVersion>4.0.0</modelVersion>
7+
<groupId>de.danielbechler</groupId>
8+
<artifactId>java-object-diff</artifactId>
9+
<name>Java Object Diff</name>
10+
<version>0.8-SNAPSHOT</version>
11+
12+
<dependencies>
13+
<dependency>
14+
<groupId>org.slf4j</groupId>
15+
<artifactId>slf4j-api</artifactId>
16+
<version>[1.6.4,)</version>
17+
</dependency>
18+
<dependency>
19+
<groupId>junit</groupId>
20+
<artifactId>junit</artifactId>
21+
<version>4.9</version>
22+
<scope>test</scope>
23+
</dependency>
24+
<dependency>
25+
<groupId>org.mockito</groupId>
26+
<artifactId>mockito-all</artifactId>
27+
<version>1.9.0</version>
28+
<scope>test</scope>
29+
</dependency>
30+
</dependencies>
31+
32+
</project>
33+

‎src/main/java/de/danielbechler/diff/AbstractObjectDiffer.java‎

Lines changed: 71 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,71 @@
1+
package de.danielbechler.diff;
2+
3+
import de.danielbechler.diff.accessor.*;
4+
import de.danielbechler.diff.annotation.*;
5+
import de.danielbechler.diff.path.*;
6+
7+
import java.util.*;
8+
9+
/** @author Daniel Bechler */
10+
public abstract class AbstractObjectDiffer
11+
{
12+
private final Collection<PropertyPath> ignoreProperties = new LinkedHashSet<PropertyPath>(10);
13+
private final Collection<PropertyPath> equalsOnlyProperties = new LinkedHashSet<PropertyPath>(10);
14+
private final Collection<Class<?>> equalsOnlyTypes = new LinkedHashSet<Class<?>>(10);
15+
16+
protected AbstractObjectDiffer()
17+
{
18+
}
19+
20+
protected AbstractObjectDiffer(final AbstractObjectDiffer source)
21+
{
22+
equalsOnlyProperties.addAll(source.equalsOnlyProperties);
23+
equalsOnlyTypes.addAll(source.equalsOnlyTypes);
24+
ignoreProperties.addAll(source.ignoreProperties);
25+
}
26+
27+
public final void addIgnoreProperty(final String property)
28+
{
29+
addIgnoreProperty(PropertyPathBuilder.pathOf(property));
30+
}
31+
32+
public final void addIgnoreProperty(final PropertyPath selectorPath)
33+
{
34+
ignoreProperties.add(selectorPath);
35+
}
36+
37+
public final <T> boolean isIgnoreProperty(final Accessor<T> accessor)
38+
{
39+
return ignoreProperties.contains(accessor.getPath());
40+
}
41+
42+
public final void setEqualsOnlyPaths(final PropertyPath... properties)
43+
{
44+
Collections.addAll(equalsOnlyProperties, properties);
45+
}
46+
47+
public final void setEqualsOnlyTypes(final Class<?>... types)
48+
{
49+
equalsOnlyTypes.addAll(Arrays.asList(types));
50+
}
51+
52+
public final void addEqualsOnlyType(final Class<?> type)
53+
{
54+
equalsOnlyTypes.add(type);
55+
}
56+
57+
public final boolean isEqualsOnlyPathOrType(final PropertyPath propertyPath, final Class<?> propertyType)
58+
{
59+
return isEqualsOnlyPath(propertyPath) || isEqualsOnlyType(propertyType);
60+
}
61+
62+
public final boolean isEqualsOnlyPath(final PropertyPath selectorPath)
63+
{
64+
return equalsOnlyProperties.contains(selectorPath);
65+
}
66+
67+
public final boolean isEqualsOnlyType(final Class<?> propertyType)
68+
{
69+
return propertyType.getAnnotation(EqualsOnlyType.class) != null || equalsOnlyTypes.contains(propertyType);
70+
}
71+
}

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

Lines changed: 174 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,174 @@
1+
package de.danielbechler.diff;
2+
3+
import de.danielbechler.diff.accessor.*;
4+
import de.danielbechler.diff.introspect.*;
5+
import de.danielbechler.diff.node.*;
6+
import de.danielbechler.diff.path.*;
7+
import de.danielbechler.util.*;
8+
9+
import java.util.*;
10+
11+
/** @author Daniel Bechler */
12+
public final class BeanDiffer extends AbstractObjectDiffer implements ObjectDiffer
13+
{
14+
private final Introspector introspector = new StandardIntrospector();
15+
16+
@SuppressWarnings({"unchecked"})
17+
public <T> DiffNode<T> compare(final T modifiedInstance, final T baseInstance)
18+
{
19+
Assert.notNull(modifiedInstance, "Missing argument [modifiedInstance]");
20+
// Assert.notNull(baseInstance, "Missing argument [baseInstance]");
21+
if (baseInstance != null && !modifiedInstance.getClass().equals(baseInstance.getClass()))
22+
{
23+
throw new IllegalArgumentException("Comparison of different types is not (yet) supported. " +
24+
"Modified was:" + modifiedInstance.getClass() + "; " +
25+
"Base was: " + baseInstance.getClass());
26+
}
27+
final Accessor<T> accessor = new RootAccessor<T>();
28+
final T defaultInstance = (T) Classes.freshInstanceOf(modifiedInstance.getClass());
29+
return compare(modifiedInstance, baseInstance, defaultInstance, accessor);
30+
}
31+
32+
public DiffNode compare(final Instances instances, final Accessor accessor)
33+
{
34+
return null;
35+
}
36+
37+
public DiffNode compare(final Object modifiedInstance,
38+
final Object baseInstance,
39+
final Object defaultInstance,
40+
final Accessor accessor)
41+
{
42+
final Accessor childAccessor;
43+
if (accessor instanceof ChainingAccessor)
44+
{
45+
childAccessor = ((ChainingAccessor) accessor).getDetachedChildAccessor();
46+
}
47+
else
48+
{
49+
childAccessor = accessor;
50+
}
51+
final Object baseValue = childAccessor.get(baseInstance);
52+
final Object modifiedValue = childAccessor.get(modifiedInstance);
53+
final Object defaultValue = childAccessor.get(defaultInstance);
54+
final PropertyPath selectorPath = accessor.getPath();
55+
if (isIgnoreProperty(accessor))
56+
{
57+
final DiffNode difference = new DefaultNode(childAccessor);
58+
difference.setType(DifferenceType.UNTOUCHED);
59+
return difference;
60+
}
61+
final Class<?> propertyType = safeTypeOf(childAccessor, baseValue, modifiedValue, defaultValue);
62+
if (Collection.class.isAssignableFrom(propertyType))
63+
{
64+
final Collection modifiedCollection = (Collection) modifiedValue;
65+
final Collection baseCollection = (Collection) baseValue;
66+
final Collection defaultCollection = (Collection) defaultValue;
67+
return new CollectionDiffer(this).compare(modifiedCollection, baseCollection, defaultCollection, accessor);
68+
}
69+
else if (Map.class.isAssignableFrom(propertyType))
70+
{
71+
return new MapDiffer(this).compare(
72+
modifiedValue != null ? Map.class.cast(modifiedValue) : null,
73+
baseValue != null ? Map.class.cast(baseValue) : null,
74+
defaultValue != null ? Map.class.cast(defaultValue) : null,
75+
accessor
76+
);
77+
}
78+
else if (propertyType.isArray())
79+
{
80+
// TODO
81+
}
82+
final DiffNode difference = new DefaultNode(childAccessor);
83+
difference.setType(DifferenceType.UNTOUCHED);
84+
if (hasBeenAdded(defaultValue, baseValue, modifiedValue))
85+
{
86+
difference.setType(DifferenceType.ADDED);
87+
}
88+
else if (hasBeenRemoved(defaultValue, baseValue, modifiedValue))
89+
{
90+
difference.setType(DifferenceType.REMOVED);
91+
}
92+
else if (modifiedValue == baseValue) // both null or both same instance
93+
{
94+
return difference;
95+
}
96+
else
97+
{
98+
if (Classes.isSimpleType(propertyType) || isEqualsOnlyPath(selectorPath) || isEqualsOnlyType(propertyType))
99+
{
100+
if (!Objects.isEqual(baseValue, modifiedValue))
101+
{
102+
difference.setType(DifferenceType.CHANGED);
103+
}
104+
}
105+
else
106+
{
107+
for (final Accessor<?> typeAccessor : introspect(propertyType))
108+
{
109+
final Accessor<Object> chain = new ChainedAccessor(accessor, typeAccessor);
110+
final DiffNode<Object> node = compare(modifiedValue, baseValue, defaultValue, chain);
111+
if (node.isDifferent())
112+
{
113+
difference.addChild(node);
114+
}
115+
}
116+
if (difference.hasChildren())
117+
{
118+
difference.setType(DifferenceType.CHANGED);
119+
}
120+
}
121+
}
122+
return difference;
123+
}
124+
125+
private static Class<?> safeTypeOf(final Accessor<?> accessor,
126+
final Object baseValue,
127+
final Object modifiedValue,
128+
final Object defaultValue)
129+
{
130+
if (accessor instanceof PropertyAccessor)
131+
{
132+
return ((PropertyAccessor) accessor).getType();
133+
}
134+
return typeOf(baseValue, modifiedValue, defaultValue);
135+
}
136+
137+
@SuppressWarnings({"unchecked"})
138+
private static <T> Class<T> typeOf(final T... values)
139+
{
140+
for (final T value : values)
141+
{
142+
if (value != null)
143+
{
144+
return (Class<T>) value.getClass();
145+
}
146+
}
147+
return (Class<T>) Object.class;
148+
// throw new RuntimeException("Couldn't extract object type");
149+
}
150+
151+
private static boolean hasBeenRemoved(final Object defaultValue, final Object baseValue, final Object updatedValue)
152+
{
153+
if (baseValue != null && updatedValue == null && !Classes.isSimpleType(baseValue.getClass()))
154+
{
155+
return true;
156+
}
157+
return Objects.isEqual(defaultValue, updatedValue) && !Objects.isEqual(baseValue, updatedValue);
158+
}
159+
160+
private static boolean hasBeenAdded(final Object defaultValue, final Object baseValue, final Object updatedValue)
161+
{
162+
// Not sure if the commented part is needed. Tests succeed without it... but not everything is tested yet.
163+
if (baseValue == null && updatedValue != null) // && !Classes.isSimpleType(updatedValue.getClass()))
164+
{
165+
return true;
166+
}
167+
return Objects.isEqual(defaultValue, baseValue) && !Objects.isEqual(baseValue, updatedValue);
168+
}
169+
170+
private Iterable<Accessor<?>> introspect(final Class<?> type)
171+
{
172+
return introspector.introspect(type);
173+
}
174+
}

0 commit comments

Comments
 (0)