More readable path formatter initialization

Author: blootsvoets

src/main/java/org/radarbase/output/path/FormattedPathFactory.kt

@@ -24,22 +24,16 @@ import java.time.Instant
 import kotlin.reflect.jvm.jvmName
 
 open class FormattedPathFactory : RecordPathFactory() {
-    private lateinit var format: String
-    private lateinit var plugins: List<PathFormatterPlugin>
     private lateinit var formatter: PathFormatter
     private lateinit var properties: Map<String, String>
     private var topicFormatters: Map<String, PathFormatter> = emptyMap()
 
     override fun init(properties: Map<String, String>) {
         super.init(properties)
 
-        format = properties["format"] ?: DEFAULT_FORMAT
-
-        plugins = instantiatePlugins(properties["plugins"] ?: DEFAULT_FORMAT_PLUGINS, properties)
-
-        logger.info("Path formatter uses format '{}' with plugins '{}'", format, plugins.map { it.name })
-
-        formatter = PathFormatter(format, plugins)
+        this.properties = DEFAULTS + properties
+        formatter = createFormatter(this.properties)
+        logger.info("Formatting path with {}", formatter)
     }
 
     private fun instantiatePlugins(
@@ -54,23 +48,20 @@ open class FormattedPathFactory : RecordPathFactory() {
     override fun addTopicConfiguration(topicConfig: Map<String, TopicConfig>) {
         topicFormatters = topicConfig
             .filter { (_, config) -> config.pathProperties.isNotEmpty() }
-            .mapValues { (topic, config) ->
-                val topicFormat = config.pathProperties.getOrDefault("format", format)
-                val pluginClassNames = config.pathProperties["plugins"]
-
-                val topicPlugins = if (pluginClassNames != null) {
-                    instantiatePlugins(pluginClassNames, properties + config.pathProperties)
-                } else plugins
+            .mapValues { (_, config) ->
+                createFormatter(properties + config.pathProperties)
+            }
+            .onEach { (topic, formatter) ->
+                logger.info("Formatting path of topic {} with {}", topic, formatter)
+            }
+    }
 
-                logger.info(
-                    "Path formatter of topic {} uses format {} with plugins {}",
-                    topic,
-                    topicFormat,
-                    topicPlugins.map { it.name }
-                )
+    private fun createFormatter(properties: Map<String, String>): PathFormatter {
+        val format = checkNotNull(properties["format"])
+        val pluginClassNames = checkNotNull(properties["plugins"])
+        val plugins = instantiatePlugins(pluginClassNames, properties)
 
-                PathFormatter(topicFormat, topicPlugins)
-            }
+        return PathFormatter(format, plugins)
     }
 
     override fun getRelativePath(
@@ -88,8 +79,10 @@ open class FormattedPathFactory : RecordPathFactory() {
     ): String = sanitizeId(key.get("sourceId"), "unknown-source")
 
     companion object {
-        internal const val DEFAULT_FORMAT = "\${projectId}/\${userId}/\${topic}/\${filename}"
-        internal const val DEFAULT_FORMAT_PLUGINS = "fixed time key value"
+        internal val DEFAULTS = mapOf(
+            "format" to "\${projectId}/\${userId}/\${topic}/\${filename}",
+            "plugins" to "fixed time key value",
+        )
         private val logger = LoggerFactory.getLogger(FormattedPathFactory::class.java)
 
         internal fun String.toPathFormatterPlugin(): PathFormatterPlugin? = when (this) {

src/main/java/org/radarbase/output/path/PathFormatter.kt

@@ -22,7 +22,7 @@ import java.nio.file.Paths
 
 class PathFormatter(
     private val format: String,
-    plugins: List<PathFormatterPlugin>
+    private val plugins: List<PathFormatterPlugin>
 ) {
     private val parameterLookups: Map<String, PathFormatParameters.() -> String>
 
@@ -37,7 +37,7 @@ class PathFormatter(
                     try {
                         plugin.createLookupTable(foundParameters)
                     } catch (ex: IllegalArgumentException) {
-                        logger.error("Cannot parse path format {}, illegal format parameter found by plugin {}", format, plugin.javaClass, ex)
+                        logger.error("Cannot parse path format {}, illegal format parameter found by plugin {}", format, plugin.name, ex)
                         throw ex
                     }
                 )
@@ -69,6 +69,10 @@ class PathFormatter(
         return Paths.get(path)
     }
 
+    override fun toString(): String = "PathFormatter{" +
+        "format=$format," +
+        "plugins=${plugins.map { it.name }}}"
+
     companion object {
         private val logger = LoggerFactory.getLogger(PathFormatter::class.java)
     }

src/test/java/org/radarbase/output/path/PathFormatterTest.kt

@@ -43,7 +43,7 @@ internal class PathFormatterTest {
     @Test
     fun testDefaultPath() {
         val formatter = PathFormatter(
-            format = FormattedPathFactory.Companion.DEFAULT_FORMAT,
+            format = checkNotNull(FormattedPathFactory.Companion.DEFAULTS["format"]),
             plugins = listOf(
                 FixedPathFormatterPlugin(),
                 TimePathFormatterPlugin(),
@@ -57,7 +57,7 @@ internal class PathFormatterTest {
     @Test
     fun testDefaultPathFewerPlugins() {
         val formatter = PathFormatter(
-            format = FormattedPathFactory.Companion.DEFAULT_FORMAT,
+            format = checkNotNull(FormattedPathFactory.Companion.DEFAULTS["format"]),
             plugins = listOf(
                 FixedPathFormatterPlugin(),
             )
@@ -68,7 +68,7 @@ internal class PathFormatterTest {
     @Test
     fun testDefaultPathNoTime() {
         val formatter = PathFormatter(
-            format = FormattedPathFactory.Companion.DEFAULT_FORMAT,
+            format = checkNotNull(FormattedPathFactory.Companion.DEFAULTS["format"]),
             plugins = listOf(
                 FixedPathFormatterPlugin(),
             )
@@ -80,7 +80,7 @@ internal class PathFormatterTest {
     fun testDefaultPathWrongPlugins() {
         assertThrows(IllegalArgumentException::class.java) {
             PathFormatter(
-                format = FormattedPathFactory.Companion.DEFAULT_FORMAT,
+                format = checkNotNull(FormattedPathFactory.Companion.DEFAULTS["format"]),
                 plugins = listOf(
                     TimePathFormatterPlugin(),
                     KeyPathFormatterPlugin(),