chore: add support for simple path resolver (#41)

Add support for a simple relection-based path resolver that aims to replace the required features of [go-funk](https://github.com/thoas/go-funk)

Since go-funk is a feature rich library (based on lodash) we are unlikely to need all the features offered. This implementation aims to provide the basic path based attribute resolution (which appears to cover the majority of our current use case). It stops short of supporting complex paths e.g. containing collections or array indexing etc.

fixes: #40

Author: mnorbury

lib/src/main/java/io/cloudquery/helper/ReflectionPathResolver.java

@@ -0,0 +1,57 @@
+package io.cloudquery.helper;
+
+import java.lang.reflect.Field;
+
+/**
+ * A simple reflection-based path resolver.
+ */
+public class ReflectionPathResolver {
+    
+    public static class PathResolverException extends Exception {
+        public PathResolverException(String message, Throwable ex) {
+            super(message, ex);
+        }
+    }
+
+    /**
+     * Resolve a path of an object using reflection.
+     * <p>
+     * e.g. if we have a class:
+     * <pre>
+     *      class TestClass {
+     *          private String name;
+     *          private TestClass child;
+     *      }
+     * </pre>
+     * <p>
+     * Then the following are valid paths to retrieve the associated values:
+     * <p>
+     * `name`
+     * `child.name`
+     * </p>
+     * NOTE: this implementation is currently very simplistic and only supports simple field and nested field resolution.
+     * It does not support collection resolution - unlike the Go SDK which uses <a href="https://github.com/thoas/go-funk#get">go-funk</a>.
+     *
+     * @param object The object to resolve the path on
+     * @param path   The path to resolve
+     * @return The value of the property at the resolved path
+     * @throws PathResolverException If the path cannot be resolved
+     */
+    public static Object resolve(Object object, String path) throws PathResolverException {
+        Object current = object;
+
+        for (String currentPath : path.split("\\.")) {
+            try {
+                Field currentField = object.getClass().getDeclaredField(currentPath);
+                if (!currentField.canAccess(current)) {
+                    currentField.setAccessible(true);
+                }
+                object = currentField.get(object);
+            } catch (NoSuchFieldException | IllegalAccessException e) {
+                throw new PathResolverException("Unable to resolve path " + currentPath, e);
+            }
+        }
+
+        return object;
+    }
+}

lib/src/test/java/io/cloudquery/helper/ReflectionPathResolverTest.java

@@ -0,0 +1,49 @@
+package io.cloudquery.helper;
+
+import lombok.Builder;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class ReflectionPathResolverTest {
+    @Builder
+    private static class TestClass {
+        private String name;
+
+        @Builder.Default
+        private List<Integer> numbers = List.of(1, 2, 3);
+
+        private TestClass singleChild;
+
+        private List<TestClass> multipleChildren;
+    }
+
+    private static final TestClass TEST_DATA = TestClass.builder().name("root").
+            singleChild(TestClass.builder().name("single-child1").build()).
+            multipleChildren(
+                    List.of(
+                            TestClass.builder().name("multi-child1").build(),
+                            TestClass.builder().name("multi-child2").build()
+                    )
+            ).
+            build();
+
+    @Test
+    public void shouldResolveSimpleFields() throws ReflectionPathResolver.PathResolverException {
+        assertEquals("root", ReflectionPathResolver.resolve(TEST_DATA, "name"));
+        assertEquals(List.of(1, 2, 3), ReflectionPathResolver.resolve(TEST_DATA, "numbers"));
+    }
+
+    @Test
+    public void shouldResolveNestedField() throws ReflectionPathResolver.PathResolverException {
+        assertEquals("single-child1", ReflectionPathResolver.resolve(TEST_DATA, "singleChild.name"));
+    }
+
+    @Test
+    public void shouldThrowAnErrorIfWeEncounterACollection() {
+        assertThrows(ReflectionPathResolver.PathResolverException.class, () -> ReflectionPathResolver.resolve(TEST_DATA, "multiplChildren.name"));
+    }
+}