Fix java output folder structure

cgen-lib/src/main/kotlin/generators/cpp/CppWritter.kt

@@ -10,18 +10,24 @@ import generators.obj.abstractSyntaxTree.Node
 import generators.obj.abstractSyntaxTree.findOrNull
 import generators.obj.abstractSyntaxTree.removeSub
 import generators.obj.syntaxParseTree.FileData
+import generators.obj.syntaxParseTree.FileMetaInformation
 import generators.obj.syntaxParseTree.ImportLeaf
 import generators.obj.syntaxParseTree.NamespaceBlock
 import generators.obj.syntaxParseTree.OutBlock
 import generators.obj.syntaxParseTree.OutBlockArguments
-import generators.obj.syntaxParseTree.FileMetaInformation
 import java.io.File
 
 class CppWritter(
     codeStyleRepo: CodeStyleRepo, outputFolder: String,
     private val reportsRepo: ReportsRepo
 ) : Writter(codeStyleRepo, outputFolder) {
 
+    override fun getFilePath(fileData: FileData): String {
+        val fileMetaInformation = fileData.findOrNull(FileMetaInformation::class.java)?.name
+            ?: throw IllegalStateException("No working directory found in fileData ${fileData.name}")
+        return fileMetaInformation + "/" + fileData.name
+    }
+
     override fun writeLeaf(leaf: Leaf, out: CodeWriter, indent: String) {
         when (leaf) {
             is CompilerDirective -> out.write("#${leaf.name}")
@@ -64,9 +70,7 @@ class CppWritter(
             reportsRepo.loge("No data to write ${fileData.name}")
             return
         }
-        val fileMetaInformation = fileData.findOrNull(FileMetaInformation::class.java)?.name
-            ?: throw IllegalStateException("No working directory found in fileData ${fileData.name}")
-        val outputFile = File(fileMetaInformation + "/" + fileData.name)
+        val outputFile = File(getFilePath(fileData))
         outputFile.parentFile.mkdirs()
         reportsRepo.logi("Writing $outputFile")
         outputFile.bufferedWriter().use { out ->

cgen-lib/src/main/kotlin/generators/java/JavaFileGenerator.kt

@@ -10,6 +10,10 @@ import generators.obj.syntaxParseTree.ImportsBlock
 import generators.obj.syntaxParseTree.NamespaceDeclaration
 import generators.obj.syntaxParseTree.OutputTree
 import generators.obj.syntaxParseTree.FileMetaInformation
+import generators.obj.syntaxParseTree.Keyword
+import generators.obj.syntaxParseTree.PackageDirectory
+import generators.obj.syntaxParseTree.VariableName
+import generators.obj.syntaxParseTree.WorkingDirectory
 import java.io.File
 
 class JavaFileGenerator() : CLikeFileGenerator() {
@@ -22,8 +26,14 @@ class JavaFileGenerator() : CLikeFileGenerator() {
     ): List<FileData> {
         return listOf(FileDataImpl(outputFile).apply {
             setParent2(project)
-            addSub(FileMetaInformation(workingDirectory))
-            addSub(NamespaceDeclaration(block.getParentPath()))
+            addSub(FileMetaInformation("").apply {
+                addSub(WorkingDirectory(workingDirectory))
+                addSub(PackageDirectory(packageDirectory))
+            })
+            addSub(NamespaceDeclaration("").apply {
+                addSub(Keyword("package"))
+                addSub(VariableName(block.getParentPath()))
+            })
             addSub(ImportsBlock())
         })
     }

cgen-lib/src/main/kotlin/generators/java/JavaWritter.kt

@@ -13,6 +13,8 @@ import generators.obj.syntaxParseTree.ImportLeaf
 import generators.obj.syntaxParseTree.NamespaceDeclaration
 import generators.obj.syntaxParseTree.OutBlock
 import generators.obj.syntaxParseTree.FileMetaInformation
+import generators.obj.syntaxParseTree.PackageDirectory
+import generators.obj.syntaxParseTree.WorkingDirectory
 import java.io.File
 
 class JavaWritter(
@@ -21,10 +23,20 @@ class JavaWritter(
     private val reportsRepo: ReportsRepo)
     : Writter(codeStyleRepo, outputFolder) {
 
-    override fun writeFile(fileData: FileData) {
-        val fileMetaInformation = fileData.findOrNull(FileMetaInformation::class.java)?.name ?:
+    override fun getFilePath(fileData: FileData): String {
+        val fileMetaInformation = fileData.findOrNull(FileMetaInformation::class.java) ?:
+            throw IllegalStateException("No working directory found in fileData ${fileData.name}")
+        val workingDirectory = fileMetaInformation.findOrNull(WorkingDirectory::class.java)?.name ?:
             throw IllegalStateException("No working directory found in fileData ${fileData.name}")
-        val outputFile = File(fileMetaInformation + "/" + fileData.name + ".java")
+        val packageDirectory = fileMetaInformation.findOrNull(PackageDirectory::class.java)?.name ?:
+            throw IllegalStateException("No package directory found in fileData ${fileData.name}")
+        return workingDirectory + File.separator +
+                packageDirectory + File.separator +
+                fileData.name + ".java"
+    }
+
+    override fun writeFile(fileData: FileData) {
+        val outputFile = File(getFilePath(fileData))
         outputFile.parentFile.mkdirs()
         reportsRepo.logi("Writing $outputFile")
         outputFile.bufferedWriter().use { out ->

cgen-lib/src/main/kotlin/generators/kotlin/KotlinWriter.kt

@@ -23,17 +23,20 @@ import java.io.File
 
 class KotlinWriter(codeStyleRepo: CodeStyleRepo, outputFolder: String)
     : Writter(codeStyleRepo, outputFolder) {
-
-    override fun writeFile(fileData: FileData) {
+    override fun getFilePath(fileData: FileData): String {
         val fileMetaInformation = fileData.findOrNull(FileMetaInformation::class.java) ?:
             throw IllegalStateException("No working directory found in fileData ${fileData.name}")
         val workingDirectory = fileMetaInformation.findOrNull(WorkingDirectory::class.java)?.name ?:
             throw IllegalStateException("No working directory found in fileData ${fileData.name}")
         val packageDirectory = fileMetaInformation.findOrNull(PackageDirectory::class.java)?.name ?:
-          throw IllegalStateException("No working directory found in fileData ${fileData.name}")
-        val outputFile = File(workingDirectory + File.separator +
+            throw IllegalStateException("No working directory found in fileData ${fileData.name}")
+        return workingDirectory + File.separator +
                 packageDirectory + File.separator +
-                fileData.name + ".kt")
+                fileData.name + ".kt"
+    }
+
+    override fun writeFile(fileData: FileData) {
+        val outputFile = File(getFilePath(fileData))
         outputFile.parentFile.mkdirs()
         println("KotlinWriter writing ${outputFile.absolutePath}")
         outputFile.bufferedWriter().use { out ->

cgen-lib/src/main/kotlin/generators/obj/Writter.kt

@@ -25,10 +25,9 @@ import java.io.File
 
 abstract class Writter(val codeStyleRepo: CodeStyleRepo,
                        outputFolderPath: String) {
-    val outFolder : File
+    val outFolder : File = File(outputFolderPath)
 
     init {
-        outFolder = File(outputFolderPath)
         outFolder.mkdirs()
     }
 
@@ -40,6 +39,7 @@ abstract class Writter(val codeStyleRepo: CodeStyleRepo,
         }
     }
 
+    abstract fun getFilePath(fileData: FileData): String
     abstract fun writeFile(fileData: FileData)
 
     open fun writeLeaf(leaf: Leaf, out: CodeWriter, indent: String) {

cgen-lib/src/main/kotlin/generators/rust/RustWritter.kt

@@ -11,12 +11,13 @@ class RustWritter(
     fileGenerator: RustFileGenerator, codeStyleRepo: CodeStyleRepo, outputFolder: String,
     private val reportsRepo: ReportsRepo
 ) : Writter(codeStyleRepo, outputFolder) {
+    override fun getFilePath(fileData: FileData): String = fileData.name + ".rs"
 
     override fun writeFile(fileData: FileData) {
 //        if (fileData.namespaces.size != 1) {
 //            throw IllegalStateException("Rust file can contain only one namespace")
 //        }
-        var outputFile = File(fileData.name + ".rs")
+        var outputFile = File(getFilePath(fileData))
         outputFile.parentFile.mkdirs()
         reportsRepo.logi("Writing $outputFile")
 //        val namespace = fileData.namespaces.entries.first().value

cgen-lib/src/main/kotlin/generators/swift/SwiftWritter.kt

@@ -12,12 +12,13 @@ class SwiftWritter(
     outputFolder: String,
     private val reportsRepo: ReportsRepo
 ) : Writter(codeStyleRepo, outputFolder) {
+    override fun getFilePath(fileData: FileData): String = fileData.name + ".swift"
 
     override fun writeFile(fileData: FileData) {
 //        if (fileData.namespaces.size != 1) {
 //            throw IllegalStateException("Swift file can contain only one namespace")
 //        }
-        var outputFile = File(fileData.name + ".swift")
+        var outputFile = File(getFilePath(fileData))
         outputFile.parentFile.mkdirs()
         reportsRepo.logi("Writing $outputFile")
 //        val namespace = fileData.namespaces.entries.first().value

cgen-lib/src/test/java/ce/writers/JavaWritterTest.kt

@@ -7,12 +7,17 @@ import ce.settings.CodeStyle
 import generators.java.JavaWritter
 import generators.obj.abstractSyntaxTree.addOutBlock
 import generators.obj.abstractSyntaxTree.addSubs
+import generators.obj.syntaxParseTree.FileDataImpl
+import generators.obj.syntaxParseTree.FileMetaInformation
 import generators.obj.syntaxParseTree.Keyword
 import generators.obj.syntaxParseTree.NlSeparator
+import generators.obj.syntaxParseTree.PackageDirectory
 import generators.obj.syntaxParseTree.RegionImpl
 import generators.obj.syntaxParseTree.Space
+import generators.obj.syntaxParseTree.WorkingDirectory
 import org.gradle.internal.impldep.org.junit.Assert
 import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
 
 class JavaWritterTest {
     val codeStyleNoSpace = CodeStyle(
@@ -56,4 +61,26 @@ class JavaWritterTest {
         }, "")
         Assert.assertEquals("public class TEST {}\n", buffer.toString())
     }
+
+    @Test
+    fun testGetFilePathWithValidFileMetaInformation() {
+        val fileMetaInfo = FileMetaInformation("").apply {
+            subs.add(WorkingDirectory("src/main/java"))
+            subs.add(PackageDirectory("com/example"))
+        }
+        val fileData = FileDataImpl("MyClass").apply {
+            subs.add(fileMetaInfo)
+        }
+        val result = writter.getFilePath(fileData)
+        Assert.assertEquals("src/main/java/com/example/MyClass.java", result)
+    }
+
+    @Test
+    fun testGetFilePathWithoutFileMetaInformationThrowsException() {
+        val fileData = FileDataImpl("")
+        val exception = assertThrows<IllegalStateException> {
+            writter.getFilePath(fileData)
+        }
+        Assert.assertTrue(exception.message?.contains("No working directory found in fileData") ?: false)
+    }
 }

cgen-lib/src/test/java/generators/java/JavaFileGeneratorTest.kt

@@ -0,0 +1,56 @@
+package generators.java
+
+import ce.defs.Target
+import generators.obj.abstractSyntaxTree.DataClass
+import generators.obj.abstractSyntaxTree.NamespaceImpl
+import generators.obj.abstractSyntaxTree.addSub
+import generators.obj.syntaxParseTree.FileData
+import generators.obj.syntaxParseTree.Keyword
+import generators.obj.syntaxParseTree.NamespaceDeclaration
+import generators.obj.syntaxParseTree.OutputTree
+import generators.obj.syntaxParseTree.FileMetaInformation
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Test
+
+class JavaFileGeneratorTest {
+
+    @Test
+    fun createFileGeneratesCorrectFileData() {
+        val generator = JavaFileGenerator()
+        val project = OutputTree(
+            target = Target.Java,
+        )
+        val namespace = "com.example.test"
+        val rootNs = NamespaceImpl("")
+        val workNs = rootNs.getNamespace(namespace)
+        project.addSub(rootNs)
+        val block = DataClass(
+            name = "TestBlock",
+            outputFile = "testOutputFile")
+        workNs.addSub(block)
+        val result = generator.createFile(project,
+            workingDirectory = "./",
+            packageDirectory = "",
+            "testOutputFile", block)
+
+        // expected result
+        // <FileData>
+        //      <FileMetaInformation>
+        //      <NamespaceDeclaration>
+        //          <keyword>package</keyword>
+        //          <VariableName>com.example.test</VariableName>
+        //      </NamespaceDeclaration>
+        assertEquals(1, result.size)
+        assertTrue(result[0] is FileData)
+        val fileData = result[0] as FileData
+        assertEquals(FileMetaInformation::class.java, fileData.subs[0].javaClass)
+        assertEquals(NamespaceDeclaration::class.java, fileData.subs[1].javaClass)
+        val nsDeclaration = fileData.subs[1] as NamespaceDeclaration
+        assertEquals(2, nsDeclaration.subs.size)
+        assertEquals(Keyword::class.java, nsDeclaration.subs[0].javaClass)
+        assertEquals("package", (nsDeclaration.subs[0] as Keyword).name)
+        assertEquals("com.example.test", nsDeclaration.subs[1].name)
+    }
+
+}