Feature/config loading from classpath (#72)

* Added new methods loadFromClassPath, loadOnceWithClasspathFallback and createMapperForName.

Modified createMapperFor-method to work with createMapperForName

* Updated main to use new method loadOnceWithClasspathFallback

* Added new test: fallback_to_classpath_when_external_file_missing()

* reworked loadOnceWithCLasspathFallback to adress external file deleted between Files.exists and load() silently bypasses the classpath fallback.

Removed unused code from main.

* Replaced new YAMLFactory() with YAMLFactory.builder().build() after feedback from coderabbit.

* Uppdated main to run both loadOnceWithClasspathFallback and cli.

* Added null preconditions after feedback from coderabbit and removed unused import.

Author: MartinStenhagen

src/main/java/org/example/App.java

@@ -11,9 +11,11 @@ public class App {
     private static final String PORT_FLAG = "--port";
 
     public static void main(String[] args) {
-        Path configPath = Path.of("src/main/resources/application.yml");
 
-        AppConfig appConfig = ConfigLoader.loadOnce(configPath);
+        AppConfig appConfig = ConfigLoader.loadOnceWithClasspathFallback(
+                Path.of("application.yml"),
+                "application.yml"
+        );
 
         int port = resolvePort(args, appConfig.server().port());
 

src/main/java/org/example/config/ConfigLoader.java

@@ -2,7 +2,6 @@
 
 import tools.jackson.databind.ObjectMapper;
 import tools.jackson.databind.json.JsonMapper;
-import tools.jackson.dataformat.yaml.YAMLFactory;
 import tools.jackson.dataformat.yaml.YAMLMapper;
 
 import java.io.InputStream;
@@ -27,6 +26,32 @@ public static AppConfig loadOnce(Path configPath) {
         }
     }
 
+    public static AppConfig loadOnceWithClasspathFallback(Path externalPath, String classpathResourceName) {
+        Objects.requireNonNull(externalPath, "externalPath");
+        Objects.requireNonNull(classpathResourceName, "classpathResourceName");
+        if (cached != null) return cached;
+
+        synchronized (ConfigLoader.class) {
+            if (cached == null){
+                AppConfig base;
+                try (InputStream ext = Files.newInputStream(externalPath)) {
+                    ObjectMapper objectMapper = createMapperFor(externalPath);
+                    AppConfig config = objectMapper.readValue(ext, AppConfig.class);
+                    base = config == null ? AppConfig.defaults() : config;
+
+                } catch (java.nio.file.NoSuchFileException ignored) {
+                    base = loadFromClasspath(classpathResourceName);
+
+                } catch (Exception e) {
+                    throw new IllegalStateException("failed to read config file " + externalPath.toAbsolutePath(), e);
+                }
+
+                cached = base.withDefaultsApplied();
+            }
+            return cached;
+        }
+    }
+
     public static AppConfig get(){
         if (cached == null){
             throw new IllegalStateException("Config not loaded. call ConfigLoader.loadOnce(...) at startup.");
@@ -52,17 +77,41 @@ public static AppConfig load(Path configPath) {
         }
     }
 
-    private static ObjectMapper createMapperFor(Path configPath) {
-        String name = configPath.getFileName().toString().toLowerCase();
+    public static AppConfig loadFromClasspath(String classpathResourceName) {
+        Objects.requireNonNull(classpathResourceName, "classpathResourceName");
+
+        try (InputStream stream = ConfigLoader.class.getClassLoader().getResourceAsStream(classpathResourceName)) {
+            if (stream == null) {
+                return AppConfig.defaults();
+            }
+
+            ObjectMapper  objectMapper = createMapperForName(classpathResourceName);
+
+            AppConfig config = objectMapper.readValue(stream, AppConfig.class);
+            return config == null ? AppConfig.defaults() : config;
+        } catch (Exception e){
+            throw new IllegalStateException("failed to read config file from classpath: " + classpathResourceName, e);
+        }
+    }
+
+    private static ObjectMapper createMapperForName(String fileName) {
+        String name = fileName.toLowerCase();
 
         if (name.endsWith(".yml") || name.endsWith(".yaml")) {
-            return YAMLMapper.builder(new YAMLFactory()).build();
+            return YAMLMapper.builder().build();
 
         } else if (name.endsWith(".json")) {
             return JsonMapper.builder().build();
         } else  {
-            return YAMLMapper.builder(new YAMLFactory()).build();
+            return YAMLMapper.builder().build();
         }
+
+    }
+
+    private static ObjectMapper createMapperFor(Path configPath) {
+        String name = configPath.getFileName().toString();
+
+        return createMapperForName(name);
     }
 
     public static void resetForTests() {

src/test/java/org/example/config/ConfigLoaderTest.java

@@ -137,5 +137,17 @@ void invalid_port_should_Throw_Exception    () throws Exception {
 
         assertThatThrownBy(() -> ConfigLoader.loadOnce(configFile))
                 .isInstanceOf(IllegalArgumentException.class).hasMessageContaining("Invalid port number");
+    }
+
+    @Test
+    @DisplayName("missing external file should fallback to classpath")
+    void fallback_to_classpath_when_external_file_missing(){
+        AppConfig appConfig = ConfigLoader.loadOnceWithClasspathFallback(tempDir.resolve("missing.yml"),"application.yml");
+
+        assertThat(appConfig.server().port()).isEqualTo(3030);
+
+
+
+
     }
 }

src/test/resources/application.yml

@@ -0,0 +1,6 @@
+server:
+  port: 3030
+  rootDir: ./from-classpath
+
+logging:
+  level: DEBUG