Allow running an application with dependent plugin classes being placed directly on the classpath

Author: graemerocher

grails-bootstrap/src/main/groovy/grails/util/Environment.java

@@ -73,6 +73,11 @@ public enum Environment {
      */
     public static String RELOAD_ENABLED = "grails.reload.enabled";
 
+    /**
+     * Constant indicating whether run-app or test-app was executed
+     */
+    public static String RUN_ACTIVE = "grails.run.active";
+
     /**
      * Whether the display of full stack traces is needed
      */
@@ -268,6 +273,15 @@ public static boolean isDevelopmentMode() {
     public static boolean isDevelopmentEnvironmentAvailable() {
         return BuildSettings.GRAILS_APP_DIR_PRESENT ;
     }
+
+    /**
+     * This method will return true the application is run
+     *
+     * @return True if the development sources are present
+     */
+    public static boolean isDevelopmentRun() {
+        return BuildSettings.GRAILS_APP_DIR_PRESENT && Boolean.getBoolean(RUN_ACTIVE);
+    }
     /**
      * Check whether the application is deployed
      * @return true if is

grails-gradle-plugin/src/main/groovy/org/grails/gradle/plugin/core/GrailsExtension.groovy

@@ -1,6 +1,7 @@
 package org.grails.gradle.plugin.core
 
 import org.apache.tools.ant.taskdefs.condition.Os
+import org.gradle.api.Project
 import org.gradle.util.ConfigureUtil
 
 /**
@@ -10,7 +11,11 @@ import org.gradle.util.ConfigureUtil
  * @since 3.0
  */
 class GrailsExtension {
+    Project project
 
+    GrailsExtension(Project project) {
+        this.project = project
+    }
     /**
      * Whether to invoke native2ascii on resource bundles
      */
@@ -34,9 +39,17 @@ class GrailsExtension {
     /**
      * Configure the reloading agent
      */
-    Agent agent(Closure configurer) {
+    Agent agent(@DelegatesTo(Agent) Closure configurer) {
         ConfigureUtil.configure(configurer, agent)
     }
+
+    /**
+     * Allows defining plugins in the available scopes
+     */
+    void plugins(Closure pluginDefinitions) {
+        def definer = new PluginDefiner(project)
+        ConfigureUtil.configure(pluginDefinitions, definer, Closure.DELEGATE_FIRST)
+    }
     /**
      * Configuration for the reloading agent
      */
@@ -52,4 +65,6 @@ class GrailsExtension {
         Map<String, String> systemProperties = ['jdk.reflect.allowGetCallerClass': 'true']
         List<String> jvmArgs = ['-Xverify:none']
     }
+
+
 }

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

@@ -79,32 +79,9 @@ class GrailsGradlePlugin extends GroovyPlugin {
     void apply(Project project) {
         super.apply(project)
 
-        def profileConfiguration = project.configurations.create(PROFILE_CONFIGURATION)
-
-        profileConfiguration.incoming.beforeResolve() {
-            if(!profileConfiguration.allDependencies) {
-                addDefaultProfile(project, profileConfiguration)
-            }
-        }
-
-        profileConfiguration.resolutionStrategy.eachDependency {
-            DependencyResolveDetails details = (DependencyResolveDetails)it
-            def group = details.requested.group ?: "org.grails.profiles"
-            def version = details.requested.version ?: BuildSettings.grailsVersion
-            details.useTarget(group: group, name:details.requested.name,version:version)
-        }
+        configureProfile(project)
 
-
-
-
-        def springBoot = project.extensions.findByType(SpringBootPluginExtension)
-        if(!springBoot) {
-            project.plugins.apply(SpringBootPlugin)
-        }
-
-        if(!project.plugins.findPlugin(DependencyManagementPlugin)) {
-            project.plugins.apply(DependencyManagementPlugin)
-        }
+        applyDefaultPlugins(project)
 
         registerToolingModelBuilder(project, registry)
 
@@ -137,11 +114,38 @@ class GrailsGradlePlugin extends GroovyPlugin {
         createBuildPropertiesTask(project)
     }
 
-    @CompileDynamic
-    void addDefaultProfile(Project project, Configuration profileConfig) {
-        project.dependencies {
-            profile  ":${System.getProperty("grails.profile") ?: 'web'}:"
+    protected void configureProfile(Project project) {
+        def profileConfiguration = project.configurations.create(PROFILE_CONFIGURATION)
+
+        profileConfiguration.incoming.beforeResolve() {
+            if (!profileConfiguration.allDependencies) {
+                addDefaultProfile(project, profileConfiguration)
+            }
+        }
+
+        profileConfiguration.resolutionStrategy.eachDependency {
+            DependencyResolveDetails details = (DependencyResolveDetails) it
+            def group = details.requested.group ?: "org.grails.profiles"
+            def version = details.requested.version ?: BuildSettings.grailsVersion
+            details.useTarget(group: group, name: details.requested.name, version: version)
+        }
+    }
+
+    @CompileStatic
+    protected void applyDefaultPlugins(Project project) {
+        def springBoot = project.extensions.findByType(SpringBootPluginExtension)
+        if (!springBoot) {
+            project.plugins.apply(SpringBootPlugin)
         }
+
+        if (!project.plugins.findPlugin(DependencyManagementPlugin)) {
+            project.plugins.apply(DependencyManagementPlugin)
+        }
+    }
+
+    @CompileStatic
+    void addDefaultProfile(Project project, Configuration profileConfig) {
+        project.dependencies.add('profile', ":${System.getProperty("grails.profile") ?: 'web'}:")
     }
 
     protected Task createBuildPropertiesTask(Project project) {
@@ -196,7 +200,7 @@ class GrailsGradlePlugin extends GroovyPlugin {
     }
 
     protected GrailsExtension registerGrailsExtension(Project project) {
-        project.extensions.create("grails", GrailsExtension)
+        project.extensions.add("grails", new GrailsExtension(project))
     }
 
     protected void configureFileWatch(Project project) {

grails-gradle-plugin/src/main/groovy/org/grails/gradle/plugin/core/GrailsPluginGradlePlugin.groovy

@@ -20,10 +20,14 @@ import groovy.transform.CompileStatic
 import org.gradle.api.Project
 import org.gradle.api.Task
 import org.gradle.api.artifacts.Configuration
+import org.gradle.api.artifacts.PublishArtifact
+import org.gradle.api.internal.tasks.DefaultTaskDependency
 import org.gradle.api.tasks.Copy
 import org.gradle.api.tasks.JavaExec
 import org.gradle.api.tasks.TaskContainer
+import org.gradle.api.tasks.TaskDependency
 import org.gradle.api.tasks.bundling.Jar
+import org.gradle.api.tasks.compile.GroovyCompile
 import org.gradle.language.jvm.tasks.ProcessResources
 import org.gradle.tooling.provider.model.ToolingModelBuilderRegistry
 
@@ -60,6 +64,8 @@ class GrailsPluginGradlePlugin extends GrailsGradlePlugin {
 
         configureSourcesJarTask(project)
 
+        configureExplodedDirConfiguration(project)
+
     }
 
     @CompileDynamic
@@ -70,6 +76,25 @@ class GrailsPluginGradlePlugin extends GrailsGradlePlugin {
         }
     }
 
+    /**
+     * Configures an exploded configuration that can be used to build the classpath of the application from subprojects that are plugins without contructing a JAR file
+     *
+     * @param project The project instance
+     */
+    @CompileStatic
+    protected void configureExplodedDirConfiguration(Project project) {
+        def configurationName = "exploded"
+        project.configurations.create(configurationName)
+
+        // add the subproject classes as outputs
+        GroovyCompile groovyCompile = (GroovyCompile)project.tasks.findByName('compileGroovy')
+        project.artifacts.add(configurationName, new ExplodedDir( groovyCompile.destinationDir, groovyCompile) )
+
+        // add the subproject resources as outputs
+        ProcessResources processResources = (ProcessResources)project.tasks.findByName("processResources")
+        project.artifacts.add(configurationName, new ExplodedDir( processResources.destinationDir, processResources) )
+    }
+
     @Override
     protected Task createBuildPropertiesTask(Project project) {
         // no-op
@@ -209,4 +234,29 @@ withConfig(configuration) {
             groovyOptions.configurationScript = configFile
         }
     }
+
+    @CompileStatic
+    static class ExplodedDir implements PublishArtifact {
+        final String extension = ""
+        final String type = "dir"
+        final Date date = new Date()
+
+        final File file
+        final TaskDependency buildDependencies
+
+        ExplodedDir(File file, Object...tasks) {
+            this.file = file
+            this.buildDependencies = new DefaultTaskDependency().add(tasks)
+        }
+
+        @Override
+        String getName() {
+            file.name
+        }
+
+        @Override
+        String getClassifier() {
+            ""
+        }
+    }
 }

grails-gradle-plugin/src/main/groovy/org/grails/gradle/plugin/core/PluginDefiner.groovy

@@ -0,0 +1,56 @@
+package org.grails.gradle.plugin.core
+
+import grails.util.Environment
+import groovy.transform.CompileStatic
+import groovy.transform.PackageScope
+import org.gradle.api.Project
+import org.gradle.api.artifacts.Dependency
+
+/**
+ * Makes it easier to define Grails plugins and also makes them aware of the development environment so that they can be run inline without creating a JAR
+ *
+ * @author Graeme Rocher
+ * @since 3.2
+ */
+@PackageScope
+class PluginDefiner {
+    Project project
+
+    PluginDefiner(Project project) {
+        this.project = project
+    }
+
+    void methodMissing(String name, args) {
+        Object[] argArray = (Object[])args
+
+        if(!argArray) {
+            throw new MissingMethodException(name, GrailsExtension, args)
+        }
+        else {
+            if(argArray[0] instanceof Map) {
+                Map notation = (Map)argArray[0]
+                if(!notation.containsKey('group')) {
+                    notation.put('group','org.grails.plugins')
+                }
+            }
+            else if(argArray[0] instanceof CharSequence) {
+                String str = argArray[0].toString()
+
+                if(str.startsWith(':')) {
+                    argArray[0] = "org.grails.plugins$str".toString()
+                }
+            }
+            project.dependencies.add(name, *argArray )
+        }
+    }
+
+    @CompileStatic
+    Dependency project(String path) {
+        if(Environment.isDevelopmentRun()) {
+            project.dependencies.project(path:path, configuration:'exploded')
+        }
+        else {
+            project.dependencies.project(path:path)
+        }
+    }
+}

grails-gradle-plugin/src/main/groovy/org/grails/gradle/plugin/run/GrailsRunTask.groovy

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2015 original authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.grails.gradle.plugin.run
+
+import org.gradle.api.tasks.JavaExec
+
+/**
+ * Extension to the standard JavaExec task to run Grails applications
+ *
+ * @author Graeme Rocher
+ * @since 3.2
+ */
+class GrailsRunTask extends JavaExec {
+}