Improve CLI output name handling by adding file extensions

analysis/import/CSVImporter/src/main/kotlin/de/maibornwolff/codecharta/importer/csv/CSVImporter.kt

@@ -1,24 +1,24 @@
 package de.maibornwolff.codecharta.importer.csv
 
+import de.maibornwolff.codecharta.serialization.OutputFileHandler
 import de.maibornwolff.codecharta.serialization.ProjectSerializer
 import de.maibornwolff.codecharta.tools.interactiveparser.InteractiveParser
 import de.maibornwolff.codecharta.tools.interactiveparser.ParserDialogInterface
 import picocli.CommandLine
-import java.io.BufferedWriter
 import java.io.File
-import java.io.FileWriter
 import java.io.IOException
 import java.io.InputStream
-import java.io.OutputStreamWriter
-import java.io.Writer
+import java.io.PrintStream
 import java.util.concurrent.Callable
 
 @CommandLine.Command(
     name = "csvimport",
     description = ["generates cc.json from csv with header"],
     footer = ["Copyright(c) 2022, MaibornWolff GmbH"]
 )
-class CSVImporter : Callable<Void>, InteractiveParser {
+class CSVImporter(
+        private val output: PrintStream = System.out,
+        private val test: Boolean = false) : Callable<Void>, InteractiveParser {
 
     @CommandLine.Option(names = ["-h", "--help"], usageHelp = true, description = ["displays this help and exits"])
     private var help = false
@@ -32,8 +32,11 @@ class CSVImporter : Callable<Void>, InteractiveParser {
     @CommandLine.Option(names = ["-nc", "--not-compressed"], description = ["save uncompressed output File"])
     private var compress = true
 
-    @CommandLine.Option(names = ["-o", "--output-file"], description = ["output File (or empty for stdout)"])
-    private var outputFile: File? = null
+    @CommandLine.Option(names = ["-o", "--output-file"], description = ["output File"])
+    private var outputFile: String? = null
+
+    @CommandLine.Option(names = ["--systemout"], description = ["write output in terminal"])
+    private var systemout = false
 
     @CommandLine.Parameters(arity = "1..*", paramLabel = "FILE", description = ["sourcemonitor csv files"])
     private var files: List<File> = mutableListOf()
@@ -44,22 +47,14 @@ class CSVImporter : Callable<Void>, InteractiveParser {
         val csvProjectBuilder = CSVProjectBuilder(pathSeparator, csvDelimiter)
         files.map { it.inputStream() }.forEach<InputStream> { csvProjectBuilder.parseCSVStream(it) }
         val project = csvProjectBuilder.build()
-        val filePath = outputFile?.absolutePath ?: "notSpecified"
-
-        if (compress && filePath != "notSpecified") ProjectSerializer.serializeAsCompressedFile(project, filePath)
-        else ProjectSerializer.serializeProject(project, writer())
+        val filePath = outputFile ?: "notSpecified"
+        if (compress && filePath != "notSpecified") ProjectSerializer.serializeAsCompressedFile(project,
+                OutputFileHandler.checkAndFixFileExtension(filePath))
+        else ProjectSerializer.serializeProject(project, OutputFileHandler.writer(outputFile ?: "", systemout || test, output))
 
         return null
     }
 
-    private fun writer(): Writer {
-        return if (outputFile == null) {
-            OutputStreamWriter(System.out)
-        } else {
-            BufferedWriter(FileWriter(outputFile))
-        }
-    }
-
     companion object {
         @JvmStatic
         fun main(args: Array<String>) {

analysis/import/CSVImporter/src/main/kotlin/de/maibornwolff/codecharta/importer/sourcemonitor/SourceMonitorImporter.kt

@@ -1,35 +1,38 @@
 package de.maibornwolff.codecharta.importer.sourcemonitor
 
 import de.maibornwolff.codecharta.importer.csv.CSVProjectBuilder
+import de.maibornwolff.codecharta.serialization.OutputFileHandler
 import de.maibornwolff.codecharta.serialization.ProjectSerializer
 import de.maibornwolff.codecharta.tools.interactiveparser.InteractiveParser
 import de.maibornwolff.codecharta.tools.interactiveparser.ParserDialogInterface
 import de.maibornwolff.codecharta.translator.MetricNameTranslator
 import picocli.CommandLine
-import java.io.BufferedWriter
 import java.io.File
-import java.io.FileWriter
 import java.io.IOException
 import java.io.InputStream
-import java.io.OutputStreamWriter
-import java.io.Writer
+import java.io.PrintStream
 import java.util.concurrent.Callable
 
 @CommandLine.Command(
     name = "sourcemonitorimport",
     description = ["generates cc.json from sourcemonitor csv"],
     footer = ["Copyright(c) 2020, MaibornWolff GmbH"]
 )
-class SourceMonitorImporter : Callable<Void>, InteractiveParser {
+class SourceMonitorImporter(
+        private val output: PrintStream = System.out,
+        private val test: Boolean = false) : Callable<Void>, InteractiveParser {
 
     @CommandLine.Option(names = ["-h", "--help"], usageHelp = true, description = ["displays this help and exits"])
     private var help = false
 
     @CommandLine.Option(names = ["-nc", "--not-compressed"], description = ["save uncompressed output File"])
     private var compress = true
 
-    @CommandLine.Option(names = ["-o", "--output-file"], description = ["output File (or empty for stdout)"])
-    private var outputFile: File? = null
+    @CommandLine.Option(names = ["-o", "--output-file"], description = ["output File"])
+    private var outputFile: String? = null
+
+    @CommandLine.Option(names = ["--systemout"], description = ["write output in terminal"])
+    private var systemout = false
 
     @CommandLine.Parameters(arity = "1..*", paramLabel = "FILE", description = ["sourcemonitor csv files"])
     private var files: List<File> = mutableListOf()
@@ -44,9 +47,10 @@ class SourceMonitorImporter : Callable<Void>, InteractiveParser {
             CSVProjectBuilder(pathSeparator, csvDelimiter, "File Name", sourceMonitorReplacement)
         files.map { it.inputStream() }.forEach<InputStream> { csvProjectBuilder.parseCSVStream(it) }
         val project = csvProjectBuilder.build()
-        val filePath = outputFile?.absolutePath ?: "notSpecified"
+        val filePath = outputFile ?: "notSpecified"
 
-        if (compress && filePath != "notSpecified") ProjectSerializer.serializeAsCompressedFile(project, filePath) else ProjectSerializer.serializeProject(project, writer())
+        if (compress && filePath != "notSpecified") ProjectSerializer.serializeAsCompressedFile(project,
+                OutputFileHandler.checkAndFixFileExtension(filePath)) else ProjectSerializer.serializeProject(project, OutputFileHandler.writer(outputFile ?: "", systemout || test, output))
 
         return null
     }
@@ -78,14 +82,6 @@ class SourceMonitorImporter : Callable<Void>, InteractiveParser {
             return MetricNameTranslator(replacementMap.toMap(), prefix)
         }
 
-    private fun writer(): Writer {
-        return if (outputFile == null) {
-            OutputStreamWriter(System.out)
-        } else {
-            BufferedWriter(FileWriter(outputFile))
-        }
-    }
-
     companion object {
         @JvmStatic
         fun main(args: Array<String>) {

analysis/import/CSVImporter/src/test/kotlin/de/maibornwolff/codecharta/importer/csv/ParserDialogTest.kt

@@ -42,8 +42,8 @@ class ParserDialogTest {
 
         val cmdLine = CommandLine(CSVImporter())
         val parseResult = cmdLine.parseArgs(*parserArguments.toTypedArray())
-        Assertions.assertThat(parseResult.matchedOption("output-file").getValue<File>().name)
-                .isEqualTo(outputFileName)
+        Assertions.assertThat(parseResult.matchedOption("output-file").getValue<String>()
+                .equals(outputFileName))
         Assertions.assertThat(parseResult.matchedOption("delimiter").getValue<Char>()).isEqualTo(delimiter[0])
         Assertions.assertThat(parseResult.matchedOption("path-separator").getValue<Char>()).isEqualTo(pathSeparator[0])
         Assertions.assertThat(parseResult.matchedOption("not-compressed").getValue<Boolean>()).isEqualTo(isCompressed)
@@ -73,8 +73,7 @@ class ParserDialogTest {
 
         val cmdLine = CommandLine(CSVImporter())
         val parseResult = cmdLine.parseArgs(*parserArguments.toTypedArray())
-        Assertions.assertThat(parseResult.matchedOption("output-file").getValue<File>().name)
-                .isEqualTo(outputFileName)
+        Assertions.assertThat(parseResult.matchedOption("output-file").getValue<String>().equals(outputFileName))
         Assertions.assertThat(parseResult.matchedOption("delimiter").getValue<Char>()).isEqualTo(delimiter[0])
         Assertions.assertThat(parseResult.matchedOption("path-separator").getValue<Char>()).isEqualTo(pathSeparator[0])
         Assertions.assertThat(parseResult.matchedOption("not-compressed").getValue<Boolean>()).isEqualTo(isCompressed)

analysis/import/CSVImporter/src/test/kotlin/de/maibornwolff/codecharta/importer/sourcemonitor/ParserDialogTest.kt

@@ -40,8 +40,7 @@ class ParserDialogTest {
 
         val cmdLine = CommandLine(SourceMonitorImporter())
         val parseResult = cmdLine.parseArgs(*parserArguments.toTypedArray())
-        Assertions.assertThat(parseResult.matchedOption("output-file").getValue<File>().name)
-                .isEqualTo(outputFileName)
+        Assertions.assertThat(parseResult.matchedOption("output-file").getValue<String>().equals(outputFileName))
         Assertions.assertThat(parseResult.matchedOption("not-compressed")).isNull()
         Assertions.assertThat(parseResult.matchedPositional(0).getValue<ArrayList<File>>()[0].name).isEqualTo(fileName)
     }

analysis/import/CodeMaatImporter/src/main/kotlin/de/maibornwolff/codecharta/importer/codemaat/CodeMaatImporter.kt

@@ -2,36 +2,39 @@ package de.maibornwolff.codecharta.importer.codemaat
 
 import de.maibornwolff.codecharta.model.AttributeType
 import de.maibornwolff.codecharta.model.AttributeTypes
+import de.maibornwolff.codecharta.serialization.OutputFileHandler
 import de.maibornwolff.codecharta.serialization.ProjectSerializer
 import de.maibornwolff.codecharta.tools.interactiveparser.InteractiveParser
 import de.maibornwolff.codecharta.tools.interactiveparser.ParserDialogInterface
 import de.maibornwolff.codecharta.translator.MetricNameTranslator
 import picocli.CommandLine
-import java.io.BufferedWriter
 import java.io.File
-import java.io.FileWriter
 import java.io.IOException
 import java.io.InputStream
-import java.io.OutputStreamWriter
-import java.io.Writer
+import java.io.PrintStream
 import java.util.concurrent.Callable
 
 @CommandLine.Command(
     name = "codemaatimport",
     description = ["generates cc.json from codemaat coupling csv"],
     footer = ["Copyright(c) 2022, MaibornWolff GmbH"]
 )
-class CodeMaatImporter : Callable<Void>, InteractiveParser {
+class CodeMaatImporter(
+        private val output: PrintStream = System.out,
+        private val test: Boolean = false) : Callable<Void>, InteractiveParser {
 
     @CommandLine.Option(names = ["-h", "--help"], usageHelp = true, description = ["displays this help and exits"])
     private var help = false
 
-    @CommandLine.Option(names = ["-o", "--output-file"], description = ["output File (or empty for stdout)"])
-    private var outputFile: File? = null
+    @CommandLine.Option(names = ["-o", "--output-file"], description = ["output File"])
+    private var outputFile: String? = null
 
     @CommandLine.Option(names = ["-nc", "--not-compressed"], description = ["save uncompressed output File"])
     private var compress = true
 
+    @CommandLine.Option(names = ["--systemout"], description = ["write output in terminal"])
+    private var systemout = false
+
     @CommandLine.Parameters(arity = "1..*", paramLabel = "FILE", description = ["codemaat coupling csv files"])
     private var files: List<File> = mutableListOf()
 
@@ -46,12 +49,12 @@ class CodeMaatImporter : Callable<Void>, InteractiveParser {
         files.map { it.inputStream() }.forEach<InputStream> { csvProjectBuilder.parseCSVStream(it) }
         val project = csvProjectBuilder.build()
 
-        val filePath = outputFile?.absolutePath ?: "notSpecified"
+        val filePath = outputFile ?: "notSpecified"
 
         if (compress && filePath != "notSpecified") ProjectSerializer.serializeAsCompressedFile(
             project,
-            filePath
-        ) else ProjectSerializer.serializeProject(project, writer())
+            OutputFileHandler.checkAndFixFileExtension(filePath)
+        ) else ProjectSerializer.serializeProject(project, OutputFileHandler.writer(outputFile ?: "", systemout || test, output))
 
         return null
     }
@@ -78,14 +81,6 @@ class CodeMaatImporter : Callable<Void>, InteractiveParser {
             return AttributeTypes(attributeTypes.toMutableMap(), type)
         }
 
-    private fun writer(): Writer {
-        return if (outputFile == null) {
-            OutputStreamWriter(System.out)
-        } else {
-            BufferedWriter(FileWriter(outputFile!!))
-        }
-    }
-
     companion object {
         @JvmStatic
         fun main(args: Array<String>) {

analysis/import/CodeMaatImporter/src/test/kotlin/de/maibornwolff/codecharta/importer/codemaat/ParserDialogTest.kt

@@ -40,7 +40,7 @@ class ParserDialogTest {
 
         val cmdLine = CommandLine(CodeMaatImporter())
         val parseResult = cmdLine.parseArgs(*parserArguments.toTypedArray())
-        Assertions.assertThat(parseResult.matchedOption("output-file").getValue<File>().name).isEqualTo(outputFileName)
+        Assertions.assertThat(parseResult.matchedOption("output-file").getValue<String>().equals(outputFileName))
         Assertions.assertThat(parseResult.matchedOption("not-compressed").getValue<Boolean>()).isEqualTo(isCompressed)
         Assertions.assertThat(parseResult.matchedPositional(0).getValue<List<File>>()[0].name).isEqualTo(fileName)
     }

analysis/import/CrococosmoImporter/src/main/kotlin/de/maibornwolff/codecharta/importer/crococosmo/CrococosmoImporter.kt

@@ -36,7 +36,8 @@ class CrococosmoImporter : Callable<Void> {
 
             val filePath = file?.absolutePath ?: "notSpecified"
 
-            if (compress && filePath != "notSpecified") ProjectSerializer.serializeAsCompressedFile(it.value, filePath)
+            if (compress && filePath != "notSpecified") ProjectSerializer.serializeAsCompressedFile(it.value,
+                    filePath)
             else ProjectSerializer.serializeProject(it.value, writer(suffix))
         }
 

analysis/import/GitLogParser/src/main/kotlin/de/maibornwolff/codecharta/importer/gitlogparser/GitLogParser.kt

@@ -7,6 +7,7 @@ import de.maibornwolff.codecharta.importer.gitlogparser.input.metrics.MetricsFac
 import de.maibornwolff.codecharta.importer.gitlogparser.parser.LogParserStrategy
 import de.maibornwolff.codecharta.importer.gitlogparser.parser.git.GitLogNumstatRawParserStrategy
 import de.maibornwolff.codecharta.model.Project
+import de.maibornwolff.codecharta.serialization.OutputFileHandler
 import de.maibornwolff.codecharta.serialization.ProjectDeserializer
 import de.maibornwolff.codecharta.serialization.ProjectSerializer
 import de.maibornwolff.codecharta.tools.interactiveparser.InteractiveParser
@@ -19,7 +20,6 @@ import picocli.CommandLine
 import java.io.File
 import java.io.IOException
 import java.io.InputStream
-import java.io.OutputStreamWriter
 import java.io.PrintStream
 import java.nio.charset.Charset
 import java.nio.file.Files
@@ -34,7 +34,8 @@ import java.util.stream.Stream
 class GitLogParser(
     private val input: InputStream = System.`in`,
     private val output: PrintStream = System.out,
-    private val error: PrintStream = System.err
+    private val error: PrintStream = System.err,
+    private val test: Boolean = false
 ) : Callable<Void>, InteractiveParser {
 
     @CommandLine.Option(names = ["-h", "--help"], usageHelp = true, description = ["displays this help and exits"])
@@ -51,8 +52,11 @@ class GitLogParser(
     )
     private var nameFile: File? = null
 
-    @CommandLine.Option(names = ["-o", "--output-file"], description = ["output File (or empty for stdout)"])
-    private var outputFile = ""
+    @CommandLine.Option(names = ["-o", "--output-file"], description = ["output File"])
+    private var outputFile: String? = null
+
+    @CommandLine.Option(names = ["--systemout"], description = ["write output in terminal"])
+    private var systemout = false
 
     @CommandLine.Option(names = ["-nc", "--not-compressed"], description = ["save uncompressed output File"], arity = "0")
     private var compress = true
@@ -109,14 +113,12 @@ class GitLogParser(
         if (pipedProject != null) {
             project = MergeFilter.mergePipedWithCurrentProject(pipedProject, project)
         }
-        if (outputFile.isNotEmpty()) {
-            if (compress) ProjectSerializer.serializeAsCompressedFile(
+        val filePath = outputFile ?: "notSpecified"
+        if (compress && filePath != "notSpecified") ProjectSerializer.serializeAsCompressedFile(
                 project,
-                outputFile
-            ) else ProjectSerializer.serializeProjectAndWriteToFile(project, outputFile)
-        } else {
-            ProjectSerializer.serializeProject(project, OutputStreamWriter(output))
-        }
+                OutputFileHandler.checkAndFixFileExtension(filePath)
+                                                                                               )
+        else ProjectSerializer.serializeProject(project, OutputFileHandler.writer(outputFile ?: "", systemout || test, output))
 
         return null
     }

analysis/import/JasomeImporter/src/main/kotlin/de/maibornwolff/codecharta/importer/jasome/JasomeImporter.kt

@@ -1,44 +1,52 @@
 package de.maibornwolff.codecharta.importer.jasome
 
+import de.maibornwolff.codecharta.serialization.OutputFileHandler
 import de.maibornwolff.codecharta.serialization.ProjectSerializer
 import picocli.CommandLine
 import java.io.File
-import java.io.Writer
+import java.io.PrintStream
 import java.util.concurrent.Callable
 
 @CommandLine.Command(
     name = "jasomeimport",
     description = ["generates cc.json from jasome xml file"],
     footer = ["Copyright(c) 2020, MaibornWolff GmbH"]
 )
-class JasomeImporter : Callable<Void> {
+class JasomeImporter(
+        private val output: PrintStream = System.out,
+        private val test: Boolean = false) : Callable<Void> {
 
     @CommandLine.Parameters(arity = "1", paramLabel = "FILE", description = ["file to parse"])
     private var file: File? = null
 
     @CommandLine.Option(names = ["-h", "--help"], usageHelp = true, description = ["displays this help and exits"])
     private var help = false
 
-    @CommandLine.Option(names = ["-o", "--output-file"], description = ["output File (or empty for stdout)"])
-    private var outputFile: File? = null
+    @CommandLine.Option(names = ["-o", "--output-file"], description = ["output File"])
+    private var outputFile: String? = null
+
+    @CommandLine.Option(names = ["--systemout"], description = ["write output in terminal"])
+    private var systemout = false
 
     @CommandLine.Option(names = ["-nc", "--not-compressed"], description = ["save uncompressed output File"])
     private var compress = true
 
     override fun call(): Void? {
         val jasomeProject = JasomeDeserializer().deserializeJasomeXML(file!!.inputStream())
         val project = JasomeProjectBuilder().add(jasomeProject).build()
-        val filePath = outputFile?.absolutePath ?: "notSpecified"
+        val filePath = outputFile ?: "notSpecified"
 
-        if (compress && filePath != "notSpecified") ProjectSerializer.serializeAsCompressedFile(project, filePath) else ProjectSerializer.serializeProject(project, writer())
+        if (compress && filePath != "notSpecified") ProjectSerializer.serializeAsCompressedFile(project,
+                OutputFileHandler.checkAndFixFileExtension(filePath)) else ProjectSerializer.serializeProject(project, OutputFileHandler.writer(outputFile ?: "", systemout || test, output))
 
         return null
     }
 
+    /**
     private fun writer(): Writer {
         return outputFile?.writer() ?: System.out.writer()
     }
-
+**/
     companion object {
 
         @JvmStatic