Make it possible to read logback version from catalog (#562)

* Make it possible to read logback version from catalog

This commit adds the ability to read the default logback version
from the `mnLogging` catalog instead of the `libs` catalog or
Gradle properties. It also removes the default version as it is
likely to be outdated in any case and raise problems.

The same should probably done for objenesis and bytebuddy but
it's unclear which projects use it in practice.

Fixes #561

* Bump JDK used to build the plugins

* Remove default version for objenesis/bytebuddy

In addition, dependencies will only be added if the version is found in
a catalog (this is also true for logback version).

For bytebuddy and objenesis, the version will be fetched from `libs`,
but also from `mnTest`. Currently, the Micronaut Test catalog doesn't
declare these, but it feels like "the right place".

* Automatically import the `mnLogging` catalog

* Bump plugin version to 6.5.x

.github/workflows/gradle.yml

@@ -23,7 +23,7 @@ jobs:
       uses: actions/setup-java@v3
       with:
         distribution: 'temurin'
-        java-version: '8'
+        java-version: '17'
     - name: Check plugin
       run: ./gradlew check
       env:

.github/workflows/release.yml

@@ -15,8 +15,8 @@ jobs:
       - name: Set up JDK
         uses: actions/setup-java@v3
         with:
-          distribution: 'adopt'
-          java-version: '8'
+          distribution: 'temurin'
+          java-version: '17'
           ref: ${{ github.head_ref }}
       - name: Set the current release version
         id: release_version

build.gradle

@@ -170,8 +170,8 @@ gradlePlugin {
 java {
     withJavadocJar()
     withSourcesJar()
-    sourceCompatibility = 8
-    targetCompatibility = 8
+    sourceCompatibility = 17
+    targetCompatibility = 17
 }
 
 def ossUser = System.getenv("SONATYPE_USERNAME") ?: project.hasProperty("sonatypeOssUsername") ? project.sonatypeOssUsername : ''

gradle.properties

@@ -1,4 +1,4 @@
-projectVersion=6.4.5-SNAPSHOT
+projectVersion=6.5.0-SNAPSHOT
 title=Micronaut Build Plugins
 projectDesc=Micronaut internal Gradle plugins. Not intended to be used in user's projects
 projectUrl=https://micronaut.io

src/main/groovy/io/micronaut/build/MicronautBuildCommonPlugin.groovy

@@ -43,9 +43,9 @@ class MicronautBuildCommonPlugin implements Plugin<Project> {
                     'org.codehaus.groovy' :
                     'org.apache.groovy'
         }
-        def byteBuddyVersionProvider = versionProviderOrDefault(project, 'bytebuddy', '1.12.18')
-        def objenesisVersionProvider = versionProviderOrDefault(project, 'objenesis', '3.1')
-        def logbackVersionProvider = versionProviderOrDefault(project, 'logback', '1.2.3')
+        def byteBuddyVersionProvider = versionProviderOrDefault(project, 'bytebuddy', List.of("libs", "mnTest"), '')
+        def objenesisVersionProvider = versionProviderOrDefault(project, 'objenesis', List.of("libs", "mnTest"),'')
+        def logbackVersionProvider = versionProviderOrDefault(project, 'logback', List.of("libs", "mnLogging"), '')
 
         project.configurations {
             documentation
@@ -89,13 +89,13 @@ class MicronautBuildCommonPlugin implements Plugin<Project> {
                 "$groovyGroup:groovy-test:$groovyVersion"
             })
             dependencies.addProvider("testImplementation", byteBuddyVersionProvider.map {
-                "net.bytebuddy:byte-buddy:$it"
+                optionalDependency("net.bytebuddy:byte-buddy", it)
             })
             dependencies.addProvider("testImplementation", objenesisVersionProvider.map {
-                "org.objenesis:objenesis:$it"
+                optionalDependency("org.objenesis:objenesis", it)
             })
             dependencies.addProvider("testRuntimeOnly", logbackVersionProvider.map {
-                "ch.qos.logback:logback-classic:$it"
+                optionalDependency("ch.qos.logback:logback-classic", it)
             })
         }
 
@@ -104,6 +104,13 @@ class MicronautBuildCommonPlugin implements Plugin<Project> {
         }
     }
 
+    private static String optionalDependency(String groupArtifact, String version) {
+        if (version == null || version.empty) {
+            return null
+        }
+        "${groupArtifact}:$version"
+    }
+
     @SuppressWarnings('GrDeprecatedAPIUsage')
     private void configureJavaPlugin(Project project, MicronautBuildExtension micronautBuildExtension) {
         project.apply plugin: "groovy"

src/main/java/io/micronaut/build/MicronautBuildSettingsExtension.java

@@ -87,6 +87,7 @@ public abstract class MicronautBuildSettingsExtension {
     private final Settings settings;
     private final String micronautVersion;
     private final String micronautTestVersion;
+    private final String micronautLoggingVersion;
     private final VersionCatalogTomlModel versionCatalogTomlModel;
 
     @Inject
@@ -100,6 +101,7 @@ public MicronautBuildSettingsExtension(ProviderFactory providers, Settings setti
         this.versionCatalogTomlModel = loadVersionCatalogTomlModel();
         this.micronautVersion = determineMicronautVersion();
         this.micronautTestVersion = determineMicronautTestVersion();
+        this.micronautLoggingVersion = determineMicronautLoggingVersion();
     }
 
     private VersionCatalogTomlModel loadVersionCatalogTomlModel() {
@@ -131,6 +133,10 @@ private String determineMicronautTestVersion() {
         return determineMicronautVersion("micronaut-test");
     }
 
+    private String determineMicronautLoggingVersion() {
+        return determineMicronautVersion("micronaut-logging");
+    }
+
     private String determineMicronautVersion(String moduleNameKebabCase) {
         Optional<String> micronautVersion = Optional.empty();
         if (versionCatalogTomlModel != null) {
@@ -176,6 +182,18 @@ public void importMicronautCatalog() {
                 });
             });
         }
+        if (micronautLoggingVersion != null) {
+            settings.getGradle().settingsEvaluated(unused -> {
+                settings.dependencyResolutionManagement(mgmt -> {
+                    configureRepositories(mgmt);
+                    if (mgmt.getVersionCatalogs().findByName("mnLogging") == null) {
+                        mgmt.getVersionCatalogs().create("mnLogging", catalog -> catalog.from("io.micronaut.logging:micronaut-logging-bom:" + micronautLoggingVersion));
+                    } else {
+                        LOGGER.warn("Version catalog 'mnLogging' can be automatically imported. You can remove it from settings.gradle(.kts) file.");
+                    }
+                });
+            });
+        }
     }
 
     private void configureRepositories(DependencyResolutionManagement mgmt) {

src/main/java/io/micronaut/build/utils/VersionHandling.java

@@ -20,33 +20,61 @@
 import org.gradle.api.artifacts.VersionConstraint;
 import org.gradle.api.provider.Provider;
 
+import java.util.ArrayDeque;
+import java.util.Collections;
+import java.util.Deque;
+import java.util.List;
 import java.util.Optional;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
 public class VersionHandling {
+    private static final List<String> DEFAULT_CATALOGS = Collections.singletonList("libs");
+
     /**
      * Returns a version defined in the catalog. If not found,
      * looks for a property (typically declared in gradle.properties).
      */
     private static String versionOrDefault(
             Project project,
             String alias,
+            List<String> catalogNames,
             String defaultVersion) {
         VersionCatalogsExtension catalogs = project.getExtensions().findByType(VersionCatalogsExtension.class);
         if (catalogs == null) {
             return projectProperty(project, alias, defaultVersion);
         }
-        return catalogs.find("libs")
+        Optional<String> version = Optional.empty();
+        Deque<String> deque = new ArrayDeque<>(catalogNames);
+        String catalogName;
+        while ((catalogName = deque.poll()) != null) {
+            String currentCatalog = catalogName;
+            version = version.or(() -> findVersionInCatalog(currentCatalog, alias, catalogs));
+        }
+        return version.orElseGet(() -> projectProperty(project, alias, defaultVersion));
+    }
+
+    private static Optional<String> findVersionInCatalog(String catalogName, String alias, VersionCatalogsExtension catalogs) {
+        return catalogs.find(catalogName)
                 .flatMap(catalog -> {
                     Optional<VersionConstraint> version = catalog.findVersion(alias);
                     if (version.isPresent()) {
                         return version;
                     }
                     return catalog.findVersion("managed." + alias);
                 })
-                .map(VersionConstraint::getRequiredVersion)
-                .orElseGet(() -> projectProperty(project, alias, defaultVersion));
+                .map(VersionConstraint::getRequiredVersion);
+    }
+
+    /**
+     * Returns a version provider defined in the catalog. If not found,
+     * looks for a property (typically declared in gradle.properties).
+     */
+    public static Provider<String> versionProviderOrDefault(
+            Project project,
+            String alias,
+            String defaultVersion) {
+        return project.provider(() -> versionOrDefault(project, alias, DEFAULT_CATALOGS, defaultVersion));
     }
 
     /**
@@ -56,8 +84,9 @@ private static String versionOrDefault(
     public static Provider<String> versionProviderOrDefault(
             Project project,
             String alias,
+            List<String> catalogNames,
             String defaultVersion) {
-        return project.provider(() -> versionOrDefault(project, alias, defaultVersion));
+        return project.provider(() -> versionOrDefault(project, alias, catalogNames, defaultVersion));
     }
 
     private static String propertyNameFor(String alias) {