Make it possible to read logback version from catalog

.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) {