Improvements to extractArgs to include ignoring fields logic

Author: Andre Bonna

README.md

@@ -28,7 +28,7 @@ Add to your pom.xml dependencies section:
 <dependency>
     <groupId>io.github.json-snapshot</groupId>
     <artifactId>json-snapshot</artifactId>
-    <version>1.0.4</version>
+    <version>1.0.6</version>
 </dependency>
 ```
 

pom.xml

@@ -5,7 +5,7 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>io.github.json-snapshot</groupId>
     <artifactId>json-snapshot</artifactId>
-    <version>1.0.5</version>
+    <version>1.0.6</version>
     <packaging>jar</packaging>
 
     <name>json-snapshot</name>

src/main/java/io/github/jsonSnapshot/SnapshotCaptor.java

@@ -0,0 +1,66 @@
+package io.github.jsonSnapshot;
+
+import java.lang.reflect.Field;
+
+public class SnapshotCaptor {
+
+    private Class<?> parameterClass;
+
+    private Class<?> argumentClass;
+
+    private String[] ignore;
+
+    public SnapshotCaptor(Class<?> parameterClass, String... ignore) {
+        this.parameterClass = parameterClass;
+        this.argumentClass = parameterClass;
+        this.ignore = ignore;
+    }
+
+    public SnapshotCaptor(Class<?> parameterClass, Class<?> argumentClass, String... ignore) {
+        this.parameterClass = parameterClass;
+        this.argumentClass = argumentClass;
+        this.ignore = ignore;
+    }
+
+    public Class<?> getParameterClass() {
+        return parameterClass;
+    }
+
+    public Object removeIgnored(Object value) {
+        Object newValue = value;
+        if (ignore != null && ignore.length > 0) {
+            newValue = shallowCopy(value);
+            for (String each : ignore) {
+                try {
+                    Field field = this.argumentClass.getDeclaredField(each);
+                    field.setAccessible(true);
+                    field.set(newValue, null);
+                } catch (IllegalAccessException | NoSuchFieldException e) {
+                    throw new SnapshotMatchException("Invalid Ignore value " + each, e.getCause());
+                }
+            }
+        }
+        return newValue;
+    }
+
+    private Object shallowCopy(Object value) {
+        try {
+            Object newValue = this.argumentClass.newInstance();
+            Field[] fields = this.argumentClass.getDeclaredFields();
+
+            for (Field field: fields) {
+                field.setAccessible(true);
+                try {
+                    field.set(newValue, field.get(value));
+                }
+                catch(Exception e) {
+                    //ignore
+                }
+            }
+            return newValue;
+        }
+        catch (Exception e) {
+            throw new SnapshotMatchException("Class "+ this.argumentClass.getSimpleName() + " must have a default empty constructor!");
+        }
+    }
+}

src/main/java/io/github/jsonSnapshot/SnapshotMatchException.java

@@ -5,4 +5,8 @@ public class SnapshotMatchException extends RuntimeException {
     SnapshotMatchException(String message) {
         super(message);
     }
+
+    SnapshotMatchException(String message, Throwable cause) {
+        super(message, cause);
+    }
 }

src/main/java/io/github/jsonSnapshot/SnapshotUtils.java

@@ -14,14 +14,36 @@
 public class SnapshotUtils {
 
     public static <T> HashMap<String, List<LinkedHashMap<String, Object>>> extractArgs(T object, String methodName,
-                                                                                       Class... classes) {
+                                                                                       SnapshotCaptor... snapshotCaptors) {
+        List<ArgumentCaptor> captors = new ArrayList<>();
+        Class[] classes = new Class[snapshotCaptors.length];
+
+        int i = 0;
+        for (SnapshotCaptor snapshotCaptor : snapshotCaptors) {
+            classes[i] = snapshotCaptor.getParameterClass();
+            captors.add(ArgumentCaptor.forClass(snapshotCaptor.getParameterClass()));
+            i++;
+        }
+
+        return process(object, methodName, captors, classes, snapshotCaptors);
+    }
+
+    public static <T> HashMap<String, List<LinkedHashMap<String, Object>>> extractArgs(T object, String methodName,
+                                                                                       Class<?>... classes) {
         List<ArgumentCaptor> captors = new ArrayList<>();
-        HashMap<String, List<LinkedHashMap<String, Object>>> result = new HashMap<>();
 
         for (Class clazz : classes) {
             captors.add(ArgumentCaptor.forClass(clazz));
         }
 
+        return process(object, methodName, captors, classes, null);
+    }
+
+    private static <T> HashMap<String, List<LinkedHashMap<String, Object>>> process(T object, String methodName,
+                                                                                    List<ArgumentCaptor> captors,
+                                                                                    Class[] classes,
+                                                                                    SnapshotCaptor[] snapshotCaptors) {
+        HashMap<String, List<LinkedHashMap<String, Object>>> result = new HashMap<>();
         try {
             Parameter[] parameters = object.getClass().getMethod(methodName, classes).getParameters();
 
@@ -42,7 +64,11 @@ public static <T> HashMap<String, List<LinkedHashMap<String, Object>>> extractAr
 
                     int j = 0;
                     for (ArgumentCaptor captor : captors) {
-                        objectMap.put(parameters[j].getName(), captor.getAllValues().get(i));
+                        Object value = captor.getAllValues().get(i);
+                        if (snapshotCaptors != null) {
+                            value = snapshotCaptors[j].removeIgnored(value);
+                        }
+                        objectMap.put(parameters[j].getName(), value);
                         j++;
                     }
                     extractedObjects.add(objectMap);
@@ -51,7 +77,7 @@ public static <T> HashMap<String, List<LinkedHashMap<String, Object>>> extractAr
 
             result.put(object.getClass().getSuperclass().getSimpleName() + "." + methodName, extractedObjects);
         } catch (Exception e) {
-            throw new SnapshotMatchException(e.getMessage());
+            throw new SnapshotMatchException(e.getMessage(), e.getCause());
         }
 
         return result;