added support for graalpy gradle plugin (#2708)

* added support for graalpy gradle plugin

* supply Kotlin Dsl to rocker template

---------

Co-authored-by: Sergio del Amo <[email protected]>

Author: tomasstupka

gradle/templates.versions.toml

@@ -71,6 +71,7 @@ spring-boot-starter-parent="3.3.5"
 graaljs = "24.0.2"  # Once this is bumped past 24.1, you should be able to remove the disabling of Loom in the config properties in the React feature.
 frontend-maven-plugin = "1.15.0"
 liquibase-slf4j = "5.0.0"
+graalpy = "24.2.0"
 
 [libraries]
 spring-boot-starter-parent = { module = "org.springframework.boot:spring-boot-starter-parent", version.ref = "spring-boot-starter-parent" }
@@ -146,6 +147,7 @@ buildless-gradle-plugin = { module = "build.less:buildless-plugin-gradle", versi
 graaljs-community = { module = "org.graalvm.polyglot:js-community", version.ref = "graaljs" }
 frontend-maven-plugin = { module = "com.github.eirslett:frontend-maven-plugin", version.ref = "frontend-maven-plugin" }
 liquibase-slf4j = { module = "com.mattbertolini:liquibase-slf4j", version.ref = "liquibase-slf4j" }
+graalpy-gradle-plugin = { module = "org.graalvm.python:org.graalvm.python.gradle.plugin", version.ref = "graalpy" }
 
 [plugins]
 # This is an exception to the rule!

starter-core/src/main/java/io/micronaut/starter/feature/graallanguages/Graalpy.java

@@ -19,15 +19,18 @@
 import io.micronaut.core.util.StringUtils;
 import io.micronaut.starter.application.ApplicationType;
 import io.micronaut.starter.application.generator.GeneratorContext;
-import io.micronaut.starter.build.BuildProperties;
 import io.micronaut.starter.build.dependencies.CoordinateResolver;
 import io.micronaut.starter.build.dependencies.Dependency;
 import io.micronaut.starter.build.dependencies.MicronautDependencyUtils;
+import io.micronaut.starter.build.gradle.GradleDsl;
+import io.micronaut.starter.build.gradle.GradlePlugin;
+import io.micronaut.starter.build.gradle.GradlePluginPortal;
 import io.micronaut.starter.build.maven.MavenPlugin;
 import io.micronaut.starter.feature.Category;
-import io.micronaut.starter.feature.MavenSpecificFeature;
+import io.micronaut.starter.feature.Feature;
 import io.micronaut.starter.feature.MinJdkFeature;
 import io.micronaut.starter.feature.graallanguages.templates.graalPyMavenPlugin;
+import io.micronaut.starter.feature.graallanguages.templates.graalPyGradlePlugin;
 import io.micronaut.starter.options.BuildTool;
 import io.micronaut.starter.options.JdkVersion;
 import io.micronaut.starter.template.RockerWritable;
@@ -38,7 +41,7 @@
 
 @Requires(property = "micronaut.starter.feature.graalpy.enabled", value = StringUtils.TRUE, defaultValue = StringUtils.TRUE)
 @Singleton
-public class Graalpy implements MinJdkFeature, MavenSpecificFeature {
+public class Graalpy implements MinJdkFeature, Feature {
     public static final String NAME = "graalpy";
 
     private static final String GROUP_ID_GRAALVM_PYTHON = "org.graalvm.python";
@@ -85,20 +88,29 @@ public void apply(GeneratorContext generatorContext) {
         addDependencies(generatorContext);
         if (generatorContext.getBuildTool() == BuildTool.MAVEN) {
             addGraalPyMavenPlugin(generatorContext);
+        } else if (generatorContext.getBuildTool().isGradle()) {
+            addGraalPyGradlePlugin(generatorContext);
         }
     }
 
     private void addGraalPyMavenPlugin(GeneratorContext generatorContext) {
-        BuildProperties buildProperties = generatorContext.getBuildProperties();
-        generatorContext.addBuildPlugin(graalpyMavenPlugin());
-    }
-
-    protected MavenPlugin graalpyMavenPlugin() {
-        return MavenPlugin.builder()
+        MavenPlugin plugin = MavenPlugin.builder()
                 .groupId(GROUP_ID_GRAALVM_PYTHON)
                 .artifactId(ARTIFACT_ID_GRAALPY_MAVEN_PLUGIN)
                 .extension(new RockerWritable(graalPyMavenPlugin.template(pythonPackages())))
                 .build();
+        generatorContext.addBuildPlugin(plugin);
+    }
+
+    private void addGraalPyGradlePlugin(GeneratorContext generatorContext) {
+        GradleDsl dsl = generatorContext.getBuildTool().getGradleDsl().orElse(GradleDsl.KOTLIN);
+        GradlePlugin plugin = GradlePlugin.builder()
+                .id("org.graalvm.python")
+                .lookupArtifactId("org.graalvm.python.gradle.plugin")
+                .extension(new RockerWritable(graalPyGradlePlugin.template(pythonPackages(), dsl)))
+                .pluginsManagementRepository(new GradlePluginPortal())
+                .build();
+        generatorContext.addBuildPlugin(plugin);
     }
 
     protected List<String> pythonPackages() {

starter-core/src/main/java/io/micronaut/starter/feature/graallanguages/templates/graalPyGradlePlugin.rocker.raw

@@ -0,0 +1,16 @@
+@import java.util.List
+@import io.micronaut.starter.build.gradle.GradleDsl
+@args (List<String> packages, GradleDsl dsl)
+//tag::graalpy-gradle-plugin[]
+@if(!packages.isEmpty()) {
+graalPy {
+@if(dsl == GradleDsl.KOTLIN) {
+    @for (String pkg : packages) {
+        packages.add(@(pkg))
+    }
+} else {
+packages = @("[\"" + String.join("\",\"",packages) + "\"]")
+}
+}
+}
+//end::graalpy-gradle-plugin[]

starter-core/src/test/groovy/io/micronaut/starter/feature/graallaguages/GraalpySpec.groovy

@@ -23,15 +23,18 @@ class GraalpySpec extends ApplicationContextSpec implements CommandOutputFixture
     @Subject
     Graalpy micronautGraalPyFeature = beanContext.getBean(Graalpy)
 
-    void 'readme.md with feature micronaut-graalpy contains links to docs'() {
+    void "readme.md with feature micronaut-graalpy contains links to docs for language=#language buildTool=#buildTool "(BuildTool buildTool, Language language) {
         when:
-        Map<String, String> output = generate(ApplicationType.DEFAULT, new Options(Language.JAVA, TestFramework.JUNIT, BuildTool.MAVEN, JdkVersion.JDK_21), [Graalpy.NAME])
+        Map<String, String> output = generate(ApplicationType.DEFAULT, new Options(language, TestFramework.JUNIT, buildTool, JdkVersion.JDK_21), [Graalpy.NAME])
         String readme = output["README.md"]
 
         then:
         readme
         readme.contains("https://micronaut-projects.github.io/micronaut-graal-languages/latest/guide");
         readme.contains("https://graalvm.org/python");
+
+        where:
+        [buildTool, language] << [BuildTool.values(), Language.JAVA].combinations()
     }
 
     void "micronaut-graalpy belongs to LANGUAGES category"() {
@@ -47,29 +50,25 @@ class GraalpySpec extends ApplicationContextSpec implements CommandOutputFixture
         applicationType << ApplicationType.values()
     }
 
-    void "micronaut-graalpy feature adds micronaut-graalpy dependency for Java and Maven "() {
+    void "micronaut-graalpy feature adds micronaut-graalpy dependency for language=#language buildTool=#buildTool "(BuildTool buildTool, Language language) {
         when:
-        String template = new BuildBuilder(beanContext, BuildTool.MAVEN)
+        String template = new BuildBuilder(beanContext, buildTool)
                 .features([Graalpy.NAME])
-                .language(Language.JAVA)
+                .language(language)
                 .render()
-        BuildTestVerifier verifier = BuildTestUtil.verifier(BuildTool.MAVEN, Language.JAVA, template)
+        BuildTestVerifier verifier = BuildTestUtil.verifier(buildTool, language, template)
 
         then:
         template
         verifier.hasDependency("io.micronaut.graal-languages", "micronaut-graalpy", Scope.COMPILE)
-    }
-
-    void "micronaut-graalpy feature adds maven-graalvm-plugin for language=java buildTool=maven "() {
-        when:
-        String template = new BuildBuilder(beanContext, BuildTool.MAVEN)
-                .features([Graalpy.NAME])
-                .language(Language.JAVA)
-                .render()
+        if (buildTool == BuildTool.MAVEN) {
+            assert template.contains("<artifactId>graalpy-maven-plugin</artifactId>")
+        } else if (buildTool.isGradle()) {
+            assert verifier.hasBuildPlugin("org.graalvm.python")
+        }
 
-        then:
-        template
-        template.contains("<artifactId>graalpy-maven-plugin</artifactId>")
+        where:
+        [buildTool, language] << [BuildTool.values(), Language.JAVA].combinations()
     }
 
     void "micronaut-graalpy feature requires java 21"() {
@@ -84,14 +83,4 @@ class GraalpySpec extends ApplicationContextSpec implements CommandOutputFixture
         ex.message == "The selected feature graalpy requires at latest Java 21"
     }
 
-    void 'test feature graalpy is only supported for Maven'() {
-        given:
-        String featureName = 'graalpy'
-        when:
-        getFeatures([featureName], new Options(Language.JAVA, TestFramework.JUNIT, BuildTool.GRADLE, JdkVersion.JDK_21))
-
-        then:
-        IllegalArgumentException ex = thrown()
-        ex.message.contains("Feature only supported by Maven")
-    }
 }