Migrate info plugin extensions to Gradle Provider API

rpalcolea · rpalcolea · commit 31036c0df2e2 · 2025-11-26T21:38:23.000-08:00
diff --git a/src/main/groovy/nebula/plugin/info/InfoBrokerPlugin.groovy b/src/main/groovy/nebula/plugin/info/InfoBrokerPlugin.groovy
@@ -57,25 +57,28 @@ class InfoBrokerPlugin implements Plugin<Project> {
     }
 
     private void filterManifestEntries(InfoBrokerPluginExtension extension) {
-        if (extension.includedManifestProperties && extension.excludedManifestProperties) {
+        boolean hasIncluded = extension.includedManifestProperties.isPresent() && !extension.includedManifestProperties.get().isEmpty()
+        boolean hasExcluded = extension.excludedManifestProperties.isPresent() && !extension.excludedManifestProperties.get().isEmpty()
+
+        if (hasIncluded && hasExcluded) {
             throw new GradleException("includedManifestProperties and excludedManifestProperties are mutually exclusive. Only one should be provided")
-        } else if (extension.excludedManifestProperties) {
+        } else if (hasExcluded) {
             removeExcludedProperties(extension)
-        } else if (extension.includedManifestProperties) {
+        } else if (hasIncluded) {
             filterOnlyIncludedProperties(extension)
         }
     }
 
     private void filterOnlyIncludedProperties(InfoBrokerPluginExtension extension) {
-        List<String> includedProperties = extension.includedManifestProperties
+        List<String> includedProperties = extension.includedManifestProperties.get()
         List<ManifestEntry> filteredManifestEntries = manifestEntries.findAll { entry ->
             (entry.name in includedProperties)
         }
         manifestEntries = filteredManifestEntries
     }
 
     private void removeExcludedProperties(InfoBrokerPluginExtension extension) {
-        List<String> excludedProperties = extension.excludedManifestProperties
+        List<String> excludedProperties = extension.excludedManifestProperties.get()
         List<ManifestEntry> filteredManifestEntries = manifestEntries.findAll { entry ->
             !(entry.name in excludedProperties)
         }
diff --git a/src/main/groovy/nebula/plugin/info/InfoBrokerPluginExtension.groovy b/src/main/groovy/nebula/plugin/info/InfoBrokerPluginExtension.groovy
@@ -1,6 +1,8 @@
 package nebula.plugin.info
 
-class InfoBrokerPluginExtension {
-    List<String> includedManifestProperties = []
-    List<String> excludedManifestProperties = []
+import org.gradle.api.provider.ListProperty
+
+abstract class InfoBrokerPluginExtension {
+    abstract ListProperty<String> getIncludedManifestProperties()
+    abstract ListProperty<String> getExcludedManifestProperties()
 }
diff --git a/src/main/groovy/nebula/plugin/info/ci/ContinuousIntegrationInfoExtension.groovy b/src/main/groovy/nebula/plugin/info/ci/ContinuousIntegrationInfoExtension.groovy
@@ -16,10 +16,12 @@
 
 package nebula.plugin.info.ci
 
-class ContinuousIntegrationInfoExtension {
-    String host
-    String job
-    String buildNumber
-    String buildId
-    String buildUrl
+import org.gradle.api.provider.Property
+
+abstract class ContinuousIntegrationInfoExtension {
+    abstract Property<String> getHost()
+    abstract Property<String> getJob()
+    abstract Property<String> getBuildNumber()
+    abstract Property<String> getBuildId()
+    abstract Property<String> getBuildUrl()
 }
diff --git a/src/main/groovy/nebula/plugin/info/ci/ContinuousIntegrationInfoPlugin.groovy b/src/main/groovy/nebula/plugin/info/ci/ContinuousIntegrationInfoPlugin.groovy
@@ -16,13 +16,10 @@
 
 package nebula.plugin.info.ci
 
-import groovy.transform.CompileDynamic
 import nebula.plugin.info.InfoBrokerPlugin
 import nebula.plugin.info.InfoCollectorPlugin
 import org.gradle.api.Plugin
 import org.gradle.api.Project
-import org.gradle.api.internal.ConventionMapping
-import org.gradle.api.internal.IConventionAware
 import org.gradle.api.provider.ProviderFactory
 
 import javax.inject.Inject
@@ -55,22 +52,20 @@ class ContinuousIntegrationInfoPlugin implements Plugin<Project>, InfoCollectorP
         configureExtMapping(project, extension)
 
         project.plugins.withType(InfoBrokerPlugin) {  InfoBrokerPlugin manifestPlugin ->
-            manifestPlugin.add('Build-Host') { extension.host }
-            manifestPlugin.add('Build-Job') { extension.job }
-            manifestPlugin.add('Build-Number') { extension.buildNumber }
-            manifestPlugin.add('Build-Id') { extension.buildId }
-            manifestPlugin.add('Build-Url') { extension.buildUrl }
+            manifestPlugin.add('Build-Host') { extension.host.getOrNull() }
+            manifestPlugin.add('Build-Job') { extension.job.getOrNull() }
+            manifestPlugin.add('Build-Number') { extension.buildNumber.getOrNull() }
+            manifestPlugin.add('Build-Id') { extension.buildId.getOrNull() }
+            manifestPlugin.add('Build-Url') { extension.buildUrl.getOrNull() }
         }
     }
 
-    @CompileDynamic
     private void configureExtMapping(Project project, ContinuousIntegrationInfoExtension extension) {
-        ConventionMapping extMapping = ((IConventionAware) extension).getConventionMapping()
-        extMapping.host = { selectedProvider.calculateHost(project) }
-        extMapping.job = { selectedProvider.calculateJob(project) }
-        extMapping.buildNumber = { selectedProvider.calculateBuildNumber(project) }
-        extMapping.buildId = { selectedProvider.calculateBuildId(project) }
-        extMapping.buildUrl = { selectedProvider.calculateBuildUrl(project) }
+        extension.host.convention(providerFactory.provider { selectedProvider.calculateHost(project) })
+        extension.job.convention(providerFactory.provider { selectedProvider.calculateJob(project) })
+        extension.buildNumber.convention(providerFactory.provider { selectedProvider.calculateBuildNumber(project) })
+        extension.buildId.convention(providerFactory.provider { selectedProvider.calculateBuildId(project) })
+        extension.buildUrl.convention(providerFactory.provider { selectedProvider.calculateBuildUrl(project) })
     }
 
     ContinuousIntegrationInfoProvider findProvider(Project project) {
diff --git a/src/main/groovy/nebula/plugin/info/scm/ScmInfoExtension.groovy b/src/main/groovy/nebula/plugin/info/scm/ScmInfoExtension.groovy
@@ -16,10 +16,12 @@
 
 package nebula.plugin.info.scm
 
-class ScmInfoExtension {
-    String origin
-    String source
-    String change
-    String fullChange
-    String branch
+import org.gradle.api.provider.Property
+
+abstract class ScmInfoExtension {
+    abstract Property<String> getOrigin()
+    abstract Property<String> getSource()
+    abstract Property<String> getChange()
+    abstract Property<String> getFullChange()
+    abstract Property<String> getBranch()
 }
diff --git a/src/main/groovy/nebula/plugin/info/scm/ScmInfoPlugin.groovy b/src/main/groovy/nebula/plugin/info/scm/ScmInfoPlugin.groovy
@@ -16,13 +16,10 @@
 
 package nebula.plugin.info.scm
 
-import groovy.transform.CompileDynamic
 import nebula.plugin.info.InfoBrokerPlugin
 import nebula.plugin.info.InfoCollectorPlugin
 import org.gradle.api.Plugin
 import org.gradle.api.Project
-import org.gradle.api.internal.ConventionMapping
-import org.gradle.api.internal.IConventionAware
 import org.gradle.api.provider.ProviderFactory
 
 import javax.inject.Inject
@@ -86,7 +83,7 @@ class ScmInfoPlugin implements Plugin<Project>, InfoCollectorPlugin {
     private void configureWithScmProvider(Project project) {
         ScmInfoExtension extension = project.extensions.create('scminfo', ScmInfoExtension)
         project.logger.debug("Project $project.name SCM information is being collected from provider ${selectedProvider.class.name}")
-        configureExtMappingWithScmProvider(project, extension)
+        configureExtensionFromProvider(project, extension)
         configureInfoBrokerManifest(project, extension)
     }
 
@@ -97,28 +94,24 @@ class ScmInfoPlugin implements Plugin<Project>, InfoCollectorPlugin {
     private void configureWithoutScmProvider(Project project, ScmInfoExtension scmInfoRootProjectExtension) {
         ScmInfoExtension extension = project.extensions.create('scminfo', ScmInfoExtension)
         project.logger.debug("Project $project.name SCM information is being collected from rootProject extension")
-        configureExtMappingWithoutScmProvider(project, extension, scmInfoRootProjectExtension)
+        configureExtensionFromRootProject(extension, scmInfoRootProjectExtension)
         configureInfoBrokerManifest(project, extension)
     }
 
-    @CompileDynamic
-    private void configureExtMappingWithScmProvider(Project project, ScmInfoExtension extension) {
-        ConventionMapping extMapping = ((IConventionAware) extension).getConventionMapping()
-        extMapping.origin = { selectedProvider.calculateOrigin(project) }
-        extMapping.source = { selectedProvider.calculateSource(project)?.replace(File.separatorChar, '/' as char) }
-        extMapping.change = { selectedProvider.calculateChange(project) }
-        extMapping.fullChange = { selectedProvider.calculateFullChange(project) }
-        extMapping.branch = { selectedProvider.calculateBranch(project) }
+    private void configureExtensionFromProvider(Project project, ScmInfoExtension extension) {
+        extension.origin.convention(providerFactory.provider { selectedProvider.calculateOrigin(project) })
+        extension.source.convention(providerFactory.provider { selectedProvider.calculateSource(project)?.replace(File.separatorChar, '/' as char) })
+        extension.change.convention(providerFactory.provider { selectedProvider.calculateChange(project) })
+        extension.fullChange.convention(providerFactory.provider { selectedProvider.calculateFullChange(project) })
+        extension.branch.convention(providerFactory.provider { selectedProvider.calculateBranch(project) })
     }
 
-    @CompileDynamic
-    private void configureExtMappingWithoutScmProvider(Project project, ScmInfoExtension extension, ScmInfoExtension scmInfoRootProjectExtension) {
-        ConventionMapping extMapping = ((IConventionAware) extension).getConventionMapping()
-        extMapping.origin = { scmInfoRootProjectExtension.origin }
-        extMapping.source = { scmInfoRootProjectExtension.source }
-        extMapping.change = { scmInfoRootProjectExtension.change }
-        extMapping.fullChange = { scmInfoRootProjectExtension.fullChange }
-        extMapping.branch = { scmInfoRootProjectExtension.branch }
+    private void configureExtensionFromRootProject(ScmInfoExtension extension, ScmInfoExtension scmInfoRootProjectExtension) {
+        extension.origin.convention(scmInfoRootProjectExtension.origin)
+        extension.source.convention(scmInfoRootProjectExtension.source)
+        extension.change.convention(scmInfoRootProjectExtension.change)
+        extension.fullChange.convention(scmInfoRootProjectExtension.fullChange)
+        extension.branch.convention(scmInfoRootProjectExtension.branch)
     }
 
     /**
@@ -128,11 +121,11 @@ class ScmInfoPlugin implements Plugin<Project>, InfoCollectorPlugin {
      */
     private void configureInfoBrokerManifest(Project project, ScmInfoExtension scmInfoExtension ) {
         project.plugins.withType(InfoBrokerPlugin) { InfoBrokerPlugin manifestPlugin ->
-            manifestPlugin.add(MODULE_SOURCE_PROPERTY) { scmInfoExtension.source }
-            manifestPlugin.add(MODULE_ORIGIN_PROPERTY) { scmInfoExtension.origin }
-            manifestPlugin.add(CHANGE_PROPERTY) { scmInfoExtension.change }
-            manifestPlugin.add(FULL_CHANGE_PROPERTY) { scmInfoExtension.fullChange }
-            manifestPlugin.add(BRANCH_PROPERTY) { scmInfoExtension.branch }
+            manifestPlugin.add(MODULE_SOURCE_PROPERTY) { scmInfoExtension.source.getOrNull() }
+            manifestPlugin.add(MODULE_ORIGIN_PROPERTY) { scmInfoExtension.origin.getOrNull() }
+            manifestPlugin.add(CHANGE_PROPERTY) { scmInfoExtension.change.getOrNull() }
+            manifestPlugin.add(FULL_CHANGE_PROPERTY) { scmInfoExtension.fullChange.getOrNull() }
+            manifestPlugin.add(BRANCH_PROPERTY) { scmInfoExtension.branch.getOrNull() }
         }
     }
 
diff --git a/src/test/groovy/nebula/plugin/info/scm/ScmInfoPluginProjectSpec.groovy b/src/test/groovy/nebula/plugin/info/scm/ScmInfoPluginProjectSpec.groovy
@@ -32,8 +32,8 @@ class ScmInfoPluginProjectSpec extends ProjectSpec {
 
         def extension = project.extensions.getByType(ScmInfoExtension)
         extension != null
-        extension.source.startsWith('/build/nebulatest')
-        extension.origin.contains('plugin')
+        extension.source.get().startsWith('/build/nebulatest')
+        extension.origin.get().contains('plugin')
     }
 
 
@@ -56,12 +56,12 @@ class ScmInfoPluginProjectSpec extends ProjectSpec {
 
         def extensionSubProjectA = subprojectA.extensions.getByType(ScmInfoExtension)
         extensionSubProjectA != null
-        extensionSubProjectA.source.startsWith('/build/nebulatest')
-        extensionSubProjectA.origin.contains('plugin')
+        extensionSubProjectA.source.get().startsWith('/build/nebulatest')
+        extensionSubProjectA.origin.get().contains('plugin')
 
         def extensionSubProjectB = subprojectB.extensions.getByType(ScmInfoExtension)
         extensionSubProjectB != null
-        extensionSubProjectB.source.startsWith('/build/nebulatest')
-        extensionSubProjectB.origin.contains('plugin')
+        extensionSubProjectB.source.get().startsWith('/build/nebulatest')
+        extensionSubProjectB.origin.get().contains('plugin')
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -57,25 +57,28 @@ class InfoBrokerPlugin implements Plugin<Project> {`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`private void filterManifestEntries(InfoBrokerPluginExtension extension) {`
`60`		`- if (extension.includedManifestProperties && extension.excludedManifestProperties) {`
	`60`	`+ boolean hasIncluded = extension.includedManifestProperties.isPresent() && !extension.includedManifestProperties.get().isEmpty()`
	`61`	`+ boolean hasExcluded = extension.excludedManifestProperties.isPresent() && !extension.excludedManifestProperties.get().isEmpty()`
	`62`	`+`
	`63`	`+ if (hasIncluded && hasExcluded) {`
`61`	`64`	`throw new GradleException("includedManifestProperties and excludedManifestProperties are mutually exclusive. Only one should be provided")`
`62`		`- } else if (extension.excludedManifestProperties) {`
	`65`	`+ } else if (hasExcluded) {`
`63`	`66`	`removeExcludedProperties(extension)`
`64`		`- } else if (extension.includedManifestProperties) {`
	`67`	`+ } else if (hasIncluded) {`
`65`	`68`	`filterOnlyIncludedProperties(extension)`
`66`	`69`	`}`
`67`	`70`	`}`
`68`	`71`
`69`	`72`	`private void filterOnlyIncludedProperties(InfoBrokerPluginExtension extension) {`
`70`		`- List<String> includedProperties = extension.includedManifestProperties`
	`73`	`+ List<String> includedProperties = extension.includedManifestProperties.get()`
`71`	`74`	`List<ManifestEntry> filteredManifestEntries = manifestEntries.findAll { entry ->`
`72`	`75`	`(entry.name in includedProperties)`
`73`	`76`	`}`
`74`	`77`	`manifestEntries = filteredManifestEntries`
`75`	`78`	`}`
`76`	`79`
`77`	`80`	`private void removeExcludedProperties(InfoBrokerPluginExtension extension) {`
`78`		`- List<String> excludedProperties = extension.excludedManifestProperties`
	`81`	`+ List<String> excludedProperties = extension.excludedManifestProperties.get()`
`79`	`82`	`List<ManifestEntry> filteredManifestEntries = manifestEntries.findAll { entry ->`
`80`	`83`	`!(entry.name in excludedProperties)`
`81`	`84`	`}`