fix: insert add-ons into the existing dependencies block

Author: Fedoseew

docs/features/add-ons.md

@@ -41,6 +41,9 @@ and does not fetch the catalog or resolve add-on dependencies.
 Additional add-ons require a compatible development JDK before generation.
 The installer adds dependencies without duplicating template entries, resolves
 artifacts with the generated Gradle wrapper, and reads module metadata from JARs.
+Selected dependencies go at the start of the module's existing `dependencies`
+block under `// Selected Jmix add-ons`. Test security prerequisites use the same
+block; installation does not append additional `dependencies` blocks.
 It configures Liquibase includes and, for add-on templates, module dependencies
 and test security. Configuration completes before Git staging.
 

src/main/kotlin/io/jmix/cli/generator/AddonInstaller.kt

@@ -18,7 +18,6 @@ import java.io.ByteArrayInputStream
 import java.io.IOException
 import java.nio.file.Files
 import java.nio.file.Path
-import java.nio.file.StandardOpenOption
 import java.util.concurrent.TimeUnit
 import java.util.jar.JarFile
 import javax.xml.XMLConstants
@@ -66,10 +65,20 @@ object AddonInstaller {
             }
         }
         if (additions.isEmpty()) return
-        val block = additions.entries.joinToString("\n", "\n// Selected Jmix add-ons\ndependencies {\n", "\n}\n") { (coordinates, value) ->
-            "    ${value.first} '$coordinates:${value.second}'"
+        val declarations = additions.entries.joinToString("\n", "// Selected Jmix add-ons\n") { (coordinates, value) ->
+            "${value.first} '$coordinates:${value.second}'"
         }
-        Files.writeString(buildFile, block, StandardOpenOption.APPEND)
+        prependDependencies(buildFile, declarations)
+    }
+
+    private fun prependDependencies(buildFile: Path, declarations: String) {
+        val text = Files.readString(buildFile)
+        val block = Regex("(?m)^dependencies[ \\t]*\\{").find(text)
+            ?: throw IOException("Cannot find the generated project's top-level dependencies block in $buildFile.")
+        val offset = block.range.last + 1
+        val newline = if ("\r\n" in text) "\r\n" else "\n"
+        val insertion = newline + declarations.prependIndent("    ").replace("\n", newline) + newline
+        Files.writeString(buildFile, text.replaceRange(offset, offset, insertion))
     }
 
     private fun resolveArtifacts(projectDir: Path, moduleDir: Path, javaHome: Path): List<Artifact> {
@@ -205,8 +214,8 @@ object AddonInstaller {
             ?: throw IOException("Cannot identify the generated add-on's test configuration for Jmix Security.")
         val starter = "io.jmix.security:jmix-security-starter"
         if (starter !in AddonProjectProfile.dependencyCoordinates(Files.readString(buildFile))) {
-            Files.writeString(buildFile, "\n// Security bootstrap for generated add-on tests\ndependencies {\n" +
-                "    testImplementation '$starter'\n}\n", StandardOpenOption.APPEND)
+            prependDependencies(buildFile, "// Security bootstrap for generated add-on tests\n" +
+                "testImplementation '$starter'")
         }
         if (files.any { Files.readString(it).contains("UserRepository") }) return
         val text = Files.readString(config)

src/test/kotlin/io/jmix/cli/generator/AddonInstallerTest.kt

@@ -15,6 +15,8 @@ import java.util.jar.JarOutputStream
 import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.io.TempDir
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.ValueSource
 
 class AddonInstallerTest {
     @TempDir lateinit var tempDir: Path
@@ -66,15 +68,37 @@ class AddonInstallerTest {
         assertThrows(IOException::class.java) { AddonInstaller.sortModules(listOf(first, second.copy(dependsOn = listOf("A")))) }
     }
 
-    @Test
-    fun `dependencies retain template entries and do not duplicate selections`() {
+    @ParameterizedTest
+    @ValueSource(strings = ["\n", "\r\n"])
+    fun `dependencies start the main block and do not duplicate selections`(newline: String) {
         val build = tempDir.resolve("build.gradle")
-        Files.writeString(build, "dependencies { implementation 'demo:existing' }\n")
+        val buildscript = """
+            buildscript {
+                dependencies { classpath 'demo:plugin' }
+            }
+
+        """.trimIndent().replace("\n", newline)
+        Files.writeString(build, buildscript + "dependencies {${newline}    implementation 'demo:existing'${newline}}$newline")
         AddonInstaller.appendDependencies(info(), build)
         AddonInstaller.appendDependencies(info(), build)
         val text = Files.readString(build)
+        assertTrue(text.startsWith(buildscript))
+        assertTrue(text.contains("dependencies {$newline    // Selected Jmix add-ons$newline    implementation 'demo:sample-starter:3.0.1'"))
+        assertEquals(1, Regex("(?m)^dependencies").findAll(text).count())
         assertTrue(text.contains("demo:existing"))
+        assertTrue(text.indexOf("demo:sample-starter") < text.indexOf("demo:existing"))
         assertEquals(1, Regex("demo:sample-starter:3.0.1").findAll(text).count())
+        if (newline == "\r\n") assertFalse(text.replace(newline, "").contains('\n'))
+    }
+
+    @Test
+    fun `missing main dependencies block leaves the build file unchanged`() {
+        val build = tempDir.resolve("build.gradle")
+        val text = "buildscript {\n    dependencies { classpath 'demo:plugin' }\n}\n"
+        Files.writeString(build, text)
+
+        assertThrows(IOException::class.java) { AddonInstaller.appendDependencies(info(), build) }
+        assertEquals(text, Files.readString(build))
     }
 
     @Test
@@ -178,6 +202,7 @@ class AddonInstallerTest {
             assertFalse(Files.readString(build).contains("security-starter"))
             repeat(2) { AddonInstaller.configureTestSecurity(build, listOf(security)) }
             assertEquals(1, Regex("testImplementation 'io.jmix.security:jmix-security-starter'").findAll(Files.readString(build)).count())
+            assertEquals(1, Regex("(?m)^dependencies").findAll(Files.readString(build)).count())
             assertEquals(if (repository.isEmpty()) 1 else 0,
                 Regex("addonTestUserRepository").findAll(Files.readString(config)).count())
             if (extension == "kt") assertTrue(Files.readString(config).contains("open fun addonTestUserRepository"))