Refactory of the strategies.

Author: jonpereiradev

pom.xml

@@ -24,10 +24,10 @@
             <scope>test</scope>
         </dependency>
         <!--<dependency>-->
-            <!--<groupId>org.mockito</groupId>-->
-            <!--<artifactId>mockito-core</artifactId>-->
-            <!--<version>1.10.19</version>-->
-            <!--<scope>test</scope>-->
+        <!--<groupId>org.mockito</groupId>-->
+        <!--<artifactId>mockito-core</artifactId>-->
+        <!--<version>1.10.19</version>-->
+        <!--<scope>test</scope>-->
         <!--</dependency>-->
     </dependencies>
 </project>

src/main/java/com/github/jonpereiradev/diffobjects/DiffObjects.java

@@ -1,54 +1,91 @@
 package com.github.jonpereiradev.diffobjects;
 
+import com.github.jonpereiradev.diffobjects.builder.DiffConfiguration;
+import com.github.jonpereiradev.diffobjects.strategy.DiffMetadata;
+import com.github.jonpereiradev.diffobjects.strategy.DiffReflections;
+
+import java.util.List;
+
 /**
  * @author jonpereiradev@gmail.com
  */
 public final class DiffObjects {
 
     /**
-     * Executa o diff entre o antes e o depois.
+     * Executa o builder entre o antes e o depois.
      *
      * @param <T>    tipo do objeto comparado.
      * @param before objeto com as informações antes da alteração.
      * @param after  objeto com as informaçnoes depois da alteração.
-     * @return resultado do diff.
+     * @return resultado do builder.
      */
     public static <T> DiffResults diff(T before, T after) {
         DiffResults result = new DiffResults();
-//        List<DiffMetadata> metadatas = DiffReflections.discover(before.getClass());
-//
-//        for (DiffMetadata metadata : metadatas) {
-//            Object beforeObject = DiffReflections.invoke(metadata.getMethod(), before);
-//            Object afterObject = DiffReflections.invoke(metadata.getMethod(), after);
-//
-//            result.diff(metadata, beforeObject, afterObject);
-//        }
+        List<DiffMetadata> metadatas = DiffReflections.discover(before.getClass());
+
+        for (DiffMetadata metadata : metadatas) {
+            result.getResults().add(metadata.getStrategy().diff(before, after, metadata));
+        }
 
         return result;
     }
 
     /**
-     * Verifica se os objetos são iguais no diff.
+     * Verifica se os objetos são iguais no builder.
      *
      * @param <T>    tipo do objeto comparado.
      * @param before objeto com as informações antes da alteração.
-     * @param after  objeto com as informaçnoes depois da alteração.
-     * @return resultado do diff.
+     * @param after  objeto com as informações depois da alteração.
+     * @return resultado do builder.
      */
     public static <T> boolean isEquals(T before, T after) {
+        List<DiffMetadata> metadatas = DiffReflections.discover(before.getClass());
+
+        for (DiffMetadata metadata : metadatas) {
+            DiffResult<T> result = metadata.getStrategy().diff(before, after, metadata);
+
+            if (!result.isEquals()) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Executa o builder entre o antes e o depois.
+     *
+     * @param <T>    tipo do objeto comparado.
+     * @param before objeto com as informações antes da alteração.
+     * @param after  objeto com as informaçnoes depois da alteração.
+     * @return resultado do builder.
+     */
+    public static <T> DiffResults diff(T before, T after, DiffConfiguration configuration) {
         DiffResults result = new DiffResults();
-//        List<DiffMetadata> metadatas = DiffReflections.discover(before.getClass());
-//
-//        for (DiffMetadata metadata : metadatas) {
-//            Object beforeObject = DiffReflections.invoke(metadata.getMethod(), before);
-//            Object afterObject = DiffReflections.invoke(metadata.getMethod(), after);
-//
-//            result.diff(metadata, beforeObject, afterObject);
-//
-//            if (!result.isEquals()) {
-//                return false;
-//            }
-//        }
+
+        for (DiffMetadata metadata : configuration.getConfigurations()) {
+            result.getResults().add(metadata.getStrategy().diff(before, after, metadata));
+        }
+
+        return result;
+    }
+
+    /**
+     * Verifica se os objetos são iguais no builder.
+     *
+     * @param <T>    tipo do objeto comparado.
+     * @param before objeto com as informações antes da alteração.
+     * @param after  objeto com as informações depois da alteração.
+     * @return resultado do builder.
+     */
+    public static <T> boolean isEquals(T before, T after, DiffConfiguration configuration) {
+        for (DiffMetadata metadata : configuration.getConfigurations()) {
+            DiffResult<T> result = metadata.getStrategy().diff(before, after, metadata);
+
+            if (!result.isEquals()) {
+                return false;
+            }
+        }
 
         return true;
     }

src/main/java/com/github/jonpereiradev/diffobjects/DiffResult.java

@@ -1,7 +1,5 @@
 package com.github.jonpereiradev.diffobjects;
 
-import com.github.jonpereiradev.diffobjects.annotation.Diff;
-
 /**
  * @author jonpereiradev@gmail.com
  */
@@ -17,11 +15,6 @@ public DiffResult(T before, T after, boolean equals) {
         this.equals = equals;
     }
 
-    public DiffResult(Diff annotation, T before, T after) {
-        this.before = before;
-        this.after = after;
-    }
-
     public T getBefore() {
         return before;
     }

src/main/java/com/github/jonpereiradev/diffobjects/DiffResults.java

@@ -10,24 +10,6 @@ public class DiffResults {
 
     private final List<DiffResult> results = new LinkedList<DiffResult>();
 
-//    void diff(DiffMetadata metadata, Object before, Object after) {
-//        DiffStrategy diffExecutable = DiffStrategyType.SINGLE.getDiffExecutable();
-//
-//        if (metadata.getStrategy() != null) {
-//            diffExecutable = metadata.getStrategy().type().getDiffExecutable();
-//        }
-//
-//        DiffResult diff = diffExecutable.diff(metadata.getAnnotation(), before, after);
-//
-//        if (diff != null) {
-//            results.add(diff);
-//        }
-//    }
-
-    public boolean isEquals() {
-        return results.isEmpty();
-    }
-
     public List<DiffResult> getResults() {
         return results;
     }

src/main/java/com/github/jonpereiradev/diffobjects/builder/DiffBuilder.java

@@ -0,0 +1,73 @@
+package com.github.jonpereiradev.diffobjects.builder;
+
+import com.github.jonpereiradev.diffobjects.strategy.DiffMetadata;
+import com.github.jonpereiradev.diffobjects.strategy.DiffReflections;
+import com.github.jonpereiradev.diffobjects.strategy.DiffStrategyType;
+import org.apache.commons.lang.StringUtils;
+
+import java.lang.reflect.Method;
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+
+public final class DiffBuilder implements DiffInstanceBuilder, DiffMappingBuilder, DiffConfiguration {
+
+    private final Class<?> classMap;
+    private final List<DiffMetadata> metadatas;
+
+    private DiffBuilder(Class<?> classMap) {
+        this.classMap = classMap;
+        this.metadatas = new LinkedList<>();
+    }
+
+    public static DiffInstanceBuilder map(Class<?> classMap) {
+        return new DiffBuilder(classMap);
+    }
+
+    @Override
+    public DiffMappingBuilder mapper() {
+        return this;
+    }
+
+    @Override
+    public DiffMappingBuilder mapping(String field) {
+        return mapping(field, StringUtils.EMPTY);
+    }
+
+    @Override
+    public DiffMappingBuilder mapping(String field, String value) {
+        Method method = DiffReflections.discoverGetter(classMap, field);
+        DiffStrategyType diffStrategyType = DiffStrategyType.SINGLE;
+
+        if (method == null) {
+            throw new IllegalArgumentException("Method " + field + " not found in class " + classMap.getName());
+        }
+
+        if (value != null && value.split("\\.").length > 1) {
+            diffStrategyType = DiffStrategyType.DEEP;
+        }
+
+        if (method.getReturnType().isAssignableFrom(Collection.class)) {
+            diffStrategyType = DiffStrategyType.COLLECTION;
+        }
+
+        metadatas.add(new DiffMetadata(value, method, diffStrategyType));
+
+        return this;
+    }
+
+    @Override
+    public DiffInstanceBuilder builder() {
+        return this;
+    }
+
+    @Override
+    public DiffConfiguration getConfiguration() {
+        return this;
+    }
+
+    @Override
+    public List<DiffMetadata> getConfigurations() {
+        return metadatas;
+    }
+}

src/main/java/com/github/jonpereiradev/diffobjects/builder/DiffConfiguration.java

@@ -0,0 +1,11 @@
+package com.github.jonpereiradev.diffobjects.builder;
+
+import com.github.jonpereiradev.diffobjects.strategy.DiffMetadata;
+
+import java.util.List;
+
+public interface DiffConfiguration {
+
+    List<DiffMetadata> getConfigurations();
+
+}

src/main/java/com/github/jonpereiradev/diffobjects/builder/DiffInstanceBuilder.java

@@ -0,0 +1,10 @@
+package com.github.jonpereiradev.diffobjects.builder;
+
+interface DiffInstanceBuilder {
+
+    DiffMappingBuilder mapper();
+
+    DiffConfiguration getConfiguration();
+
+}
+

src/main/java/com/github/jonpereiradev/diffobjects/builder/DiffMappingBuilder.java

@@ -0,0 +1,12 @@
+package com.github.jonpereiradev.diffobjects.builder;
+
+interface DiffMappingBuilder {
+
+    DiffInstanceBuilder builder();
+
+    DiffMappingBuilder mapping(String field);
+
+    DiffMappingBuilder mapping(String field, String value);
+
+}
+

src/main/java/com/github/jonpereiradev/diffobjects/strategy/DiffCollectionStrategy.java

@@ -4,43 +4,79 @@
 
 import java.lang.reflect.Method;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.Iterator;
 
+/**
+ * Responsible for check the difference between two collections.
+ *
+ * @author jonpereiradev@gmail.com
+ */
 final class DiffCollectionStrategy implements DiffStrategy {
 
+    /**
+     * Check the difference between two objects for the diffMetadata configuration.
+     *
+     * @param before       object that is considered a state before the after object.
+     * @param after        object that is considered the before object updated.
+     * @param diffMetadata the diffMetadata that is mapped to make the builder.
+     * @param <T>          the type of object returned by the builder.
+     * @return the builder result between the two objects.
+     */
     @Override
-    public <T> DiffResult<T> diff(Object before, Object after, Method method) {
-        Collection<T> beforeCollection = DiffReflections.invoke(method, before);
-        Collection<T> afterCollection = DiffReflections.invoke(method, after);
+    public <T> DiffResult<T> diff(Object before, Object after, DiffMetadata diffMetadata) {
+        Collection<?> beforeCollection = initializeCollection(before, diffMetadata.getMethod());
+        Collection<?> afterCollection = initializeCollection(after, diffMetadata.getMethod());
 
-        if (beforeCollection == null) {
-            beforeCollection = Collections.emptyList();
+        if (beforeCollection == null && afterCollection == null) {
+            return new DiffResult<>(null, null, true);
         }
 
-        if (afterCollection == null) {
-            afterCollection = Collections.emptyList();
-        }
-
-        boolean isEquals = beforeCollection.size() == afterCollection.size();
-
-        if (beforeCollection.size() == afterCollection.size()) {
+        if (isEqualsSize(beforeCollection, afterCollection)) {
             Iterator<?> beforeIterator = beforeCollection.iterator();
             Iterator<?> afterIterator = afterCollection.iterator();
-            DiffStrategy diffStrategy = DiffStrategyType.DEEP.getStrategy();
 
             while (beforeIterator.hasNext() && afterIterator.hasNext()) {
-                Object beforeObject = beforeIterator.next();
-                Object afterObject = afterIterator.next();
-
-                isEquals = diffStrategy.diff(beforeObject, afterObject, method) == null;
+                if (diffMetadata.getValue().isEmpty()) {
+                    Object beforeObject = beforeIterator.next();
+                    Object afterObject = afterIterator.next();
 
-                if (!isEquals) {
-                    break;
+                    if (!beforeObject.equals(afterObject)) {
+                        return new DiffResult<>((T) beforeCollection, (T) afterCollection, false);
+                    }
                 }
             }
         }
 
-        return isEquals ? null : new DiffResult<T>(null, null, false);
+        return new DiffResult<>((T) beforeCollection, (T) afterCollection, true);
+    }
+
+    private boolean isEqualsSize(Collection<?> beforeCollection, Collection<?> afterCollection) {
+        if (beforeCollection == null && !afterCollection.isEmpty()) {
+            return false;
+        }
+
+        return beforeCollection != null && afterCollection != null && beforeCollection.isEmpty();
+    }
+
+    /**
+     * Inicializa a coleção de objetos para verificação do builder.
+     *
+     * @param object
+     * @param method
+     * @param <T>
+     * @return
+     */
+    private <T> Collection<T> initializeCollection(Object object, Method method) {
+        Collection<T> collection = null;
+
+        if (object != null) {
+            collection = DiffReflections.invoke(method, object);
+        }
+
+        if (collection != null && collection.isEmpty()) {
+            return null;
+        }
+
+        return collection;
     }
 }