There are lots of internal chanes to Filelizer.

Author: jottinger

src/main/java/io/github/filelize/Filelizer.java

@@ -23,7 +23,7 @@ public class Filelizer implements IFilelizer {
 
     public Filelizer(String basePath) {
         var objectMapper = new ObjectMapper();
-        objectMapper.registerModule(new JavaTimeModule());
+        objectMapper.findAndRegisterModules();
         objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
         this.filelizerObject = new FilelizerObject(basePath, objectMapper);
         this.filelizerSingle = new FilelizerSingle(basePath, objectMapper);
@@ -32,78 +32,63 @@ public Filelizer(String basePath) {
     }
 
     public Filelizer(String basePath, ObjectMapper objectMapper, FilelizeType defaultFilelizeType) {
-        objectMapper.registerModule(new JavaTimeModule());
+        objectMapper.findAndRegisterModules();
         objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
         this.filelizerObject = new FilelizerObject(basePath, objectMapper);
         this.filelizerSingle = new FilelizerSingle(basePath, objectMapper);
         this.filelizerMultiple = new FilelizerMultiple(basePath, objectMapper);
         this.defaultFilelizeType = defaultFilelizeType;
     }
 
+    private IFilelizer resolveFilelizerType(Object valueType) {
+        return resolveFilelizerType(getFilelizeType(valueType, defaultFilelizeType));
+    }
+
+    private IFilelizer resolveFilelizerType(FilelizeType filelizeType) {
+        // I do not like this implementation. It's mandated because of object graph structure and Java 11.
+        // With Java 17 or later, this becomes a switch expression and is much nicer.
+        IFilelizer filelizer = null;
+        switch (filelizeType) {
+            case MULTIPLE_FILES:
+                filelizer = filelizerMultiple;
+                break;
+            case SINGLE_FILE:
+                filelizer = filelizerSingle;
+                break;
+            case OBJECT_FILE:
+                filelizer = filelizerObject;
+                break;
+        }
+        return filelizer;
+    }
+
     @Override
     public <T> T find(String id, Class<T> valueType) {
-        var filelizeType = getFilelizeType(valueType, defaultFilelizeType);
-        if(filelizeType == FilelizeType.SINGLE_FILE) {
-            return filelizerSingle.find(id, valueType);
-        } else if(filelizeType == FilelizeType.MULTIPLE_FILES) {
-            return filelizerMultiple.find(id, valueType);
-        }
-        return filelizerObject.find(id, valueType);
+        return resolveFilelizerType(valueType).find(id, valueType);
     }
 
     @Override
     public <T> Map<String, T> findAll(Class<T> valueType) {
-        var filelizeType = getFilelizeType(valueType, defaultFilelizeType);
-        if(filelizeType == FilelizeType.SINGLE_FILE) {
-            return filelizerSingle.findAll(valueType);
-        } else if(filelizeType == FilelizeType.MULTIPLE_FILES) {
-            return filelizerMultiple.findAll(valueType);
-        }
-        return filelizerObject.findAll(valueType);
+        return resolveFilelizerType(valueType).findAll(valueType);
     }
 
     @Override
     public <T> String save(T object) {
-        var filelizeType = getFilelizeType(object, defaultFilelizeType);
-        if(filelizeType == FilelizeType.SINGLE_FILE) {
-            return filelizerSingle.save(object);
-        } else if(filelizeType == FilelizeType.MULTIPLE_FILES) {
-            return filelizerMultiple.save(object);
-        }
-        return filelizerObject.save(object);
+        return resolveFilelizerType(object).save(object);
     }
 
     @Override
     public <T> String save(String id, T object) {
-        var filelizeType = getFilelizeType(object, defaultFilelizeType);
-        if(filelizeType == FilelizeType.SINGLE_FILE) {
-            return filelizerSingle.save(id, object);
-        } else if(filelizeType == FilelizeType.MULTIPLE_FILES) {
-            return filelizerMultiple.save(id, object);
-        }
-        return filelizerObject.save(id, object);
+        return resolveFilelizerType(object).save(id, object);
     }
 
     @Override
     public <T> List<String> saveAll(List<T> objects) {
-        var filelizeType = getFilelizeTypeOfList(objects, defaultFilelizeType);
-        if(filelizeType == FilelizeType.SINGLE_FILE) {
-            return filelizerSingle.saveAll(objects);
-        } else if(filelizeType == FilelizeType.MULTIPLE_FILES) {
-            return filelizerMultiple.saveAll(objects);
-        }
-        return filelizerObject.saveAll(objects);
+        return resolveFilelizerType(getFilelizeTypeOfList(objects, defaultFilelizeType)).saveAll(objects);
     }
 
     @Override
     public <T> void delete(String id, Class<T> valueType) {
-        var filelizeType = getFilelizeType(valueType, defaultFilelizeType);
-        if(filelizeType == FilelizeType.SINGLE_FILE) {
-            filelizerSingle.delete(id, valueType);
-        } else if(filelizeType == FilelizeType.MULTIPLE_FILES) {
-            filelizerMultiple.delete(id, valueType);
-        } else {
-            filelizerObject.delete(id, valueType);
-        }
+        resolveFilelizerType(valueType).delete(id, valueType);
     }
 }

src/main/java/io/github/filelize/FilelizerObject.java

@@ -29,7 +29,7 @@ public <T> T find(String id, Class<T> valueType) {
         try {
             return fileHandler.readFile(fullPath, valueType);
         } catch (IOException e) {
-            log.error("Error occurred when trying to get " + fullPath, e);
+            log.error(String.format("Error occurred when trying to get %s", fullPath), e);
             return null;
         }
     }
@@ -71,7 +71,7 @@ public <T> void delete(String id, Class<T> valueType) {
         try {
             fileHandler.delete(fullPath);
         } catch (IOException e) {
-            log.error("Error occurred when trying to delete " + fullPath, e);
+            log.error(String.format("Error occurred when trying to delete %s", fullPath), e);
         }
     }
 }

src/main/java/io/github/filelize/path/PathHandler.java

@@ -7,6 +7,7 @@
 
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Objects;
 
 import static io.github.filelize.FilelizeUtil.*;
 
@@ -75,10 +76,8 @@ private String getFilename(String id, String name) {
         return name + "_" + id + ".json";
     }
     private String getDirectoryPath(Object object){
-        if(object != null) {
-            return basePath + "/" + getFilelizeDirectory(object);
-        }
-        return basePath;
+        Objects.requireNonNull(object);
+        return basePath + "/" + getFilelizeDirectory(object);
     }
 
 }

src/test/java/io/github/filelize/file/FileHandlerTest.java

@@ -7,6 +7,7 @@
 import java.io.IOException;
 
 import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.fail;
 
 public class FileHandlerTest {
 
@@ -17,9 +18,13 @@ public FileHandlerTest() {
     }
 
     @Test
-    public void testReadFile_ShouldHandleNoSuchFileException() throws IOException {
-        var something = fileHandler.readFile("tmp/not_existing_folder.json", SomethingElse.class);
-        assertNull(something);
+    public void testReadFile_ShouldHandleNoSuchFileException() {
+        try {
+            var something = fileHandler.readFile("tmp/not_existing_folder.json", SomethingElse.class);
+            assertNull(something);
+        } catch(IOException e) {
+            fail(e);
+        }
     }
 
 }