fix profile resolution from inside of a grails project

Author: jdaugherty

grails-doc/src/en/guide/profiles/profileInheritance.adoc

@@ -22,7 +22,7 @@ One profile can extend one or many different parent profiles. To define profile
 [source,groovy]
 ----
 dependencies {
-    profileRuntimeOnly "org.apache.grails.profiles:base:{version}"
+    profileRuntimeApi "org.apache.grails.profiles:base:{version}"
 }
 ----
 

grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy

@@ -36,6 +36,7 @@ import org.gradle.api.Task
 import org.gradle.api.artifacts.Configuration
 import org.gradle.api.artifacts.Dependency
 import org.gradle.api.artifacts.DependencyResolveDetails
+import org.gradle.api.artifacts.DependencySet
 import org.gradle.api.file.Directory
 import org.gradle.api.file.DuplicatesStrategy
 import org.gradle.api.file.FileCollection
@@ -79,7 +80,6 @@ import javax.inject.Inject
 @CompileStatic
 class GrailsGradlePlugin extends GroovyPlugin {
     public static final String APPLICATION_CONTEXT_COMMAND_CLASS = 'grails.dev.commands.ApplicationCommand'
-    public static final String PROFILE_CONFIGURATION = 'profile'
 
     protected static final List<String> CORE_GORM_LIBRARIES = ['async', 'core', 'simple', 'web', 'rest-client', 'gorm', 'gorm-validation', 'gorm-plugin-support', 'gorm-support', 'test-support', 'hibernate-core', 'gorm-test', 'rx', 'rx-plugin-support']
     // NOTE: mongodb, neo4j etc. should NOT be included here so they can be independently versioned
@@ -269,11 +269,28 @@ class GrailsGradlePlugin extends GroovyPlugin {
     }
 
     protected void configureProfile(Project project) {
-        if(!project.configurations.names.contains(PROFILE_CONFIGURATION)) {
-            project.configurations.register(PROFILE_CONFIGURATION).configure { Configuration profileConfiguration ->
-                profileConfiguration.incoming.beforeResolve() {
-                    if (!profileConfiguration.allDependencies) {
-                        addDefaultProfile(project, profileConfiguration)
+        if(!project.configurations.names.contains(GrailsClasspathToolingModelBuilder.PROFILE_CONFIGURATION_NAME)) {
+            project.configurations.register(GrailsClasspathToolingModelBuilder.PROFILE_CONFIGURATION_NAME).configure { Configuration profileConfiguration ->
+                profileConfiguration.description = "Configuration that allows for finding profile artifacts so commands, scripts, and other helpers can be found by the Grails Shell"
+                profileConfiguration.canBeConsumed = false
+                profileConfiguration.canBeResolved = true
+                profileConfiguration.transitive = true
+
+                profileConfiguration.defaultDependencies { DependencySet deps ->
+                    String defaultProfileCoordinates = "org.apache.grails.profiles:${System.getProperty("grails.profile") ?: getDefaultProfile()}:${project.properties['grailsVersion'] ?: BuildSettings.grailsVersion}" as String
+                    project.logger.info('No Grails profile is defined for project {}, defaulting to: {}', project.name, defaultProfileCoordinates)
+                    deps.add (
+                            project.dependencies.create(defaultProfileCoordinates)
+                    )
+                }
+
+                profileConfiguration.resolutionStrategy.eachDependency { details ->
+                    if(details.requested.group == 'org.apache.grails.profiles' && !details.requested.version) {
+                        String grailsVersion = (project.findProperty('grailsVersion') ?: BuildSettings.grailsVersion) as String
+                        project.logger.info('Dependency: {}:{} did not define a version, defaulting to grails version {}', details.requested.group, details.requested.name, grailsVersion)
+
+                        details.useVersion(grailsVersion)
+                        details.because("Grails Profile defined without a version, defaulting to configured Grails Version")
                     }
                 }
             }
@@ -317,12 +334,6 @@ class GrailsGradlePlugin extends GroovyPlugin {
         'web'
     }
 
-    void addDefaultProfile(Project project, Configuration profileConfig) {
-        def bomProject = project.rootProject.subprojects.find { it.name == 'grails-bom' }
-        project.dependencies.add(PROFILE_CONFIGURATION, project.dependencies.platform(bomProject ?: "org.apache.grails:grails-bom:${project.properties.get('grailsVersion')}"))
-        project.dependencies.add(PROFILE_CONFIGURATION, "org.apache.grails.profiles:${System.getProperty("grails.profile") ?: defaultProfile}:")
-    }
-
     @CompileDynamic
     protected Task createBuildPropertiesTask(Project project) {
         if (project.tasks.findByName('buildProperties') == null) {

grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/model/GrailsClasspathToolingModelBuilder.groovy

@@ -30,26 +30,26 @@ import org.gradle.tooling.provider.model.ToolingModelBuilder
  */
 @CompileStatic
 class GrailsClasspathToolingModelBuilder implements ToolingModelBuilder {
+    public static final String PROFILE_CONFIGURATION_NAME = "profile"
+
     @Override
     boolean canBuild(String modelName) {
         return modelName == GrailsClasspath.name
     }
 
     @Override
     Object buildAll(String modelName, Project project) {
-        // testRuntimeClasspath includes provided
         try {
-
             List<URL> runtimeDependencies = project.getConfigurations().getByName("testRuntimeClasspath").getResolvedConfiguration().getResolvedArtifacts().collect { ResolvedArtifact artifact ->
                 artifact.getFile().toURI().toURL()
             }
 
             DefaultGrailsClasspath grailsClasspath = new DefaultGrailsClasspath(dependencies: runtimeDependencies)
 
-            Configuration profileConfiguration = project.getConfigurations().getByName("profile")
+            Configuration profileConfiguration = project.getConfigurations().getByName(PROFILE_CONFIGURATION_NAME)
             if (profileConfiguration != null) {
-                grailsClasspath.profileDependencies = profileConfiguration.getResolvedConfiguration().getResolvedArtifacts().collect() { ResolvedArtifact artifact ->
-                    artifact.getFile().toURI().toURL()
+                grailsClasspath.profileDependencies = profileConfiguration.resolvedConfiguration.resolvedArtifacts.collect() { ResolvedArtifact artifact ->
+                    artifact.file.toURI().toURL()
                 }
             }
             return grailsClasspath

grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/profiles/GrailsProfileGradlePlugin.groovy

@@ -22,19 +22,16 @@ import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.Task
 import org.gradle.api.artifacts.Configuration
-import org.gradle.api.attributes.AttributeCompatibilityRule
-import org.gradle.api.attributes.Bundling
 import org.gradle.api.attributes.Category
-import org.gradle.api.attributes.CompatibilityCheckDetails
-import org.gradle.api.attributes.LibraryElements
 import org.gradle.api.attributes.Usage
-import org.gradle.api.component.AdhocComponentWithVariants
 import org.gradle.api.component.SoftwareComponentFactory
 import org.gradle.api.file.CopySpec
 import org.gradle.api.file.Directory
 import org.gradle.api.file.SyncSpec
 import org.gradle.api.model.ObjectFactory
 import org.gradle.api.plugins.BasePlugin
+import org.gradle.api.plugins.GroovyPlugin
+import org.gradle.api.plugins.JavaLibraryPlugin
 import org.gradle.api.tasks.TaskProvider
 import org.gradle.api.tasks.bundling.Jar
 import org.grails.gradle.plugin.profiles.tasks.ProfileCompilerTask
@@ -52,11 +49,8 @@ import static org.gradle.api.plugins.BasePlugin.BUILD_GROUP
 @CompileStatic
 class GrailsProfileGradlePlugin implements Plugin<Project> {
 
-    static final String USAGE_PROFILE_NAME = 'profile-runtime'
-    static final String COMPONENT_NAME = 'profile'
-    static final String RUNTIME_API_CONFIGURATION = 'profileRuntimeApi'
-    // to add dependencies for that profile's scripts
-    static final String RUNTIME_ONLY_CONFIGURATION = 'profileRuntimeOnly' // to be used to extend profiles
+    // to be used to extend profiles
+    static final String PROFILE_API_CONFIGURATION = 'profileRuntimeApi'
 
     private final SoftwareComponentFactory softwareComponentFactory
     private final ObjectFactory objectFactory
@@ -70,50 +64,26 @@ class GrailsProfileGradlePlugin implements Plugin<Project> {
     @Override
     void apply(Project project) {
         project.pluginManager.apply(BasePlugin)
-
-        Usage profileUsage = objectFactory.named(Usage, USAGE_PROFILE_NAME)
-
-        project.dependencies.attributesSchema {
-            it.attribute(Usage.USAGE_ATTRIBUTE) {
-                it.compatibilityRules.add(JavaRuntimeCompatibility)
+        project.pluginManager.apply(GroovyPlugin)
+        project.pluginManager.apply(JavaLibraryPlugin)
+
+        NamedDomainObjectProvider<Configuration> runtimeOnlyConfiguration = project.configurations.register(PROFILE_API_CONFIGURATION)
+        runtimeOnlyConfiguration.configure { Configuration config ->
+            config.description = 'Profiles to inherit for this profile project'
+            config.canBeConsumed = true
+            config.canBeResolved = true
+
+            config.attributes {
+                it.attribute(Usage.USAGE_ATTRIBUTE, project.objects.named(Usage, Usage.JAVA_RUNTIME))
+                it.attribute(Category.CATEGORY_ATTRIBUTE, project.objects.named(Category, Category.LIBRARY))
             }
         }
 
-        AdhocComponentWithVariants profileComponent = softwareComponentFactory.adhoc(COMPONENT_NAME)
-        project.components.add(profileComponent)
+        project.configurations.named("apiElements")
+                .configure { it.extendsFrom(runtimeOnlyConfiguration.get()) }
 
-        NamedDomainObjectProvider<Configuration> runtimeApiConfiguration = project.configurations.register(RUNTIME_API_CONFIGURATION)
-        runtimeApiConfiguration.configure { Configuration it ->
-            it.description = 'Dependencies exported transitively to other profile projects'
-            it.canBeConsumed = false
-            it.canBeResolved = false
-            it.attributes {
-                it.attribute(Usage.USAGE_ATTRIBUTE, profileUsage)
-                it.attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, objectFactory.named(LibraryElements, LibraryElements.CLASSES))
-                it.attribute(Category.CATEGORY_ATTRIBUTE, objectFactory.named(Category, Category.LIBRARY))
-                it.attribute(Bundling.BUNDLING_ATTRIBUTE, objectFactory.named(Bundling, Bundling.EXTERNAL))
-            }
-            profileComponent.addVariantsFromConfiguration(it) {
-                it.mapToMavenScope('compile')
-            }
-        }
-
-        NamedDomainObjectProvider<Configuration> runtimeOnlyConfiguration = project.configurations.register(RUNTIME_ONLY_CONFIGURATION)
-        runtimeOnlyConfiguration.configure { Configuration it ->
-            it.description = 'Dependencies required to compile a profile project'
-            it.canBeConsumed = true
-            it.canBeResolved = true
-            it.extendsFrom(runtimeApiConfiguration.get())
-            it.attributes {
-                it.attribute(Usage.USAGE_ATTRIBUTE, profileUsage)
-                it.attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, objectFactory.named(LibraryElements, LibraryElements.JAR))
-                it.attribute(Category.CATEGORY_ATTRIBUTE, objectFactory.named(Category, Category.LIBRARY))
-                it.attribute(Bundling.BUNDLING_ATTRIBUTE, objectFactory.named(Bundling, Bundling.EXTERNAL))
-            }
-            profileComponent.addVariantsFromConfiguration(it) {
-                it.mapToMavenScope('runtime')
-            }
-        }
+        project.configurations.named("runtimeElements")
+                .configure { it.extendsFrom(runtimeOnlyConfiguration.get()) }
 
         TaskProvider<Task> processProfileResourcesTask = project.tasks.register('processProfileResources')
         processProfileResourcesTask.configure { Task task ->
@@ -203,22 +173,21 @@ class GrailsProfileGradlePlugin implements Plugin<Project> {
                 }
                 return null
             }
-            it.classpath = runtimeOnlyConfiguration.get()
+            it.classpath = project.files(runtimeOnlyConfiguration.get(), project.configurations.named('runtimeClasspath').get())
         }
 
-        TaskProvider<Jar> jarTask = project.tasks.register('profileJar', Jar)
+        TaskProvider<Jar> jarTask = project.tasks.named('jar', Jar)
         jarTask.configure { Jar jar ->
-            jar.group = BUILD_GROUP
-            jar.dependsOn(processProfileResourcesTask, compileTask, project.tasks.named('jar', Jar).orNull)
+            jar.dependsOn(processProfileResourcesTask, compileTask)
 
             jar.from(project.files(project.layout.buildDirectory.dir('resources/profile'), project.layout.buildDirectory.dir('classes/profile')))
-            jar.destinationDirectory.set(project.layout.buildDirectory.dir('libs'))
-            jar.description = 'Assembles a jar archive containing the profile classes.'
             jar.reproducibleFileOrder = true
             jar.preserveFileTimestamps = false
+            jar.dirMode = 0755 // To avoid platform specific defaults
+            jar.fileMode = 0644 // to avoid platform specific defaults
         }
 
-        TaskProvider<Jar> sourcesJarTask = project.tasks.register('sourcesProfileJar', Jar)
+        TaskProvider<Jar> sourcesJarTask = project.tasks.register('sourcesJar', Jar)
         sourcesJarTask.configure { Jar jar ->
             jar.from(project.layout.projectDirectory.dir('commands'))
             if (project.file('profile.yml').exists()) {
@@ -235,7 +204,8 @@ class GrailsProfileGradlePlugin implements Plugin<Project> {
             jar.description = 'Assembles a jar archive containing the profile sources.'
             jar.reproducibleFileOrder = true
             jar.preserveFileTimestamps = false
-            jar.group = BUILD_GROUP
+            jar.dirMode = 0755 // To avoid platform specific defaults
+            jar.fileMode = 0644 // to avoid platform specific defaults
         }
 
         def profileReadme = project.layout.buildDirectory.file('profile.txt')
@@ -251,8 +221,17 @@ class GrailsProfileGradlePlugin implements Plugin<Project> {
             }
         }
 
-        TaskProvider<Jar> javadocJarTask = project.tasks.register('javadocProfileJar', Jar)
+        project.tasks.named('javadoc').configure {
+            it.enabled = false // will replace the java doc
+        }
+
+        TaskProvider<Jar> javadocJarTask = project.tasks.register('javadocJar', Jar)
         javadocJarTask.configure { Jar jar ->
+            jar.reproducibleFileOrder = true
+            jar.preserveFileTimestamps = false
+            jar.dirMode = 0755 // To avoid platform specific defaults
+            jar.fileMode = 0644 // to avoid platform specific defaults
+
             jar.dependsOn(readmeGeneration)
             // https://central.sonatype.org/publish/requirements/#supply-javadoc-and-sources
             jar.from(profileReadme) { CopySpec spec ->
@@ -262,25 +241,6 @@ class GrailsProfileGradlePlugin implements Plugin<Project> {
             jar.destinationDirectory.set(new File(project.layout.buildDirectory.asFile.get(), 'libs'))
             jar.description = 'Assembles a jar archive containing the profile javadoc.'
             jar.group = BUILD_GROUP
-            jar.reproducibleFileOrder = true
-            jar.preserveFileTimestamps = false
-        }
-
-        project.tasks.named('assemble').configure { Task it ->
-            it.dependsOn(jarTask)
-        }
-    }
-}
-
-/**
- * I'm not sure why a separate configuration was originally created for the profiles, but maybe they are combined
- * into a single gradle project.  For compatibility purposes, treat java-runtime as a usable substitute
- */
-class JavaRuntimeCompatibility implements AttributeCompatibilityRule<Usage> {
-    @Override
-    void execute(CompatibilityCheckDetails<Usage> d) {
-        if (d.consumerValue.name == GrailsProfileGradlePlugin.USAGE_PROFILE_NAME && d.producerValue.name == Usage.JAVA_RUNTIME) {
-            d.compatible()
         }
     }
 }

grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/profiles/GrailsProfilePublishGradlePlugin.groovy

@@ -21,7 +21,6 @@ package org.grails.gradle.plugin.profiles
 import groovy.transform.CompileStatic
 import org.gradle.api.GradleException
 import org.gradle.api.Project
-import org.gradle.api.attributes.Usage
 import org.gradle.api.model.ObjectFactory
 import org.gradle.api.publish.maven.MavenPublication
 import org.gradle.api.publish.maven.tasks.GenerateMavenPom
@@ -75,18 +74,6 @@ class GrailsProfilePublishGradlePlugin extends GrailsPublishGradlePlugin {
 
     @Override
     protected void doAddArtefact(Project project, MavenPublication publication) {
-        publication.from(project.components.named(GrailsProfileGradlePlugin.COMPONENT_NAME).get())
-        publication.artifact(project.tasks.named('profileJar'))
-        publication.artifact(project.tasks.named('sourcesProfileJar'))
-        publication.artifact(project.tasks.named('javadocProfileJar'))
-
-        publication.versionMapping {
-            it.variant(Usage.USAGE_ATTRIBUTE, objectFactory.named(Usage, GrailsProfileGradlePlugin.USAGE_PROFILE_NAME)) {
-                it.fromResolutionOf(GrailsProfileGradlePlugin.RUNTIME_API_CONFIGURATION)
-            }
-            it.variant(Usage.USAGE_ATTRIBUTE, objectFactory.named(Usage, GrailsProfileGradlePlugin.USAGE_PROFILE_NAME)) {
-                it.fromResolutionOf(GrailsProfileGradlePlugin.RUNTIME_ONLY_CONFIGURATION)
-            }
-        }
+        publication.from project.components.named('java').get()
     }
 }

grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/profiles/tasks/ProfileCompilerTask.groovy

@@ -139,7 +139,7 @@ class ProfileCompilerTask extends AbstractCompile {
 
         if (!profileData.containsKey('extends')) {
             List<String> dependencies = []
-            project.configurations.named(GrailsProfileGradlePlugin.RUNTIME_ONLY_CONFIGURATION).get().dependencies.all { Dependency d ->
+            project.configurations.named(GrailsProfileGradlePlugin.PROFILE_API_CONFIGURATION).get().dependencies.all { Dependency d ->
                 String profileName = d.name
                 if (d instanceof DefaultProjectDependency) {
                     DefaultProjectDependency projectDependency = (DefaultProjectDependency) d

grails-profiles/base/build.gradle

@@ -15,7 +15,6 @@
  *  limitations under the License.
  */
 plugins {
-    id 'groovy'
     id 'org.apache.grails.gradle.grails-profile'
 }
 
@@ -30,9 +29,9 @@ ext {
 }
 
 dependencies {
-    profileRuntimeApi platform(project(':grails-bom'))
-    profileRuntimeApi project(':grails-shell-cli')
-    profileRuntimeApi 'org.apache.groovy:groovy-jmx' // stop script uses GroovyMBean
+    implementation platform(project(':grails-bom'))
+    api project(':grails-shell-cli')
+    api 'org.apache.groovy:groovy-jmx' // stop script uses GroovyMBean
 }
 
 TaskProvider<Copy> copyWrapper = tasks.register('copyGrailsWrapperScripts', Copy)
@@ -47,7 +46,7 @@ copyWrapper.configure { Copy copy ->
     copy.into(project.layout.projectDirectory.dir('skeleton'))
 }
 
-tasks.named('sourcesProfileJar').configure {
+tasks.named('sourcesJar').configure {
     it.dependsOn(copyWrapper)
 }
 

grails-profiles/plugin/build.gradle

@@ -15,7 +15,6 @@
  *  limitations under the License.
  */
 plugins {
-    id 'groovy'
     id 'org.apache.grails.gradle.grails-profile'
 }
 
@@ -30,7 +29,7 @@ ext {
 }
 
 dependencies {
-    profileRuntimeOnly project(":grails-profiles-base")
+    profileRuntimeApi project(":grails-profiles-base")
 }
 
 apply {