Merge pull request #22 from Cognifide/include-projects

Making assemblies with filters merging

Author: pun-ky

README.md

@@ -1,4 +1,4 @@
-![Cognifide logo](doc/cognifide-logo.png)
+![Cognifide logo](docs/cognifide-logo.png)
 
 [![Gradle Status](https://gradleupdate.appspot.com/Cognifide/gradle-aem-plugin/status.svg)](https://gradleupdate.appspot.com/Cognifide/gradle-aem-plugin/status)
 [![Apache License, Version 2.0, January 2004](https://img.shields.io/github/license/Cognifide/gradle-aem-plugin.svg?label=License)](http://www.apache.org/licenses/)
@@ -7,7 +7,7 @@
 
 <br>
 <p align="center">
-  <img src="doc/logo.png" alt="Gradle AEM Plugin Logo"/>
+  <img src="docs/logo.png" alt="Gradle AEM Plugin Logo"/>
 </p>
 <br>
 
@@ -50,7 +50,7 @@ buildscript {
     }
     
     dependencies {
-        classpath 'com.cognifide.gradle:aem-plugin:1.0.+'
+        classpath 'com.cognifide.gradle:aem-plugin:1.2.+'
     }
 }
 
@@ -120,6 +120,7 @@ Snippet above demonstrates customizations valid only for specific project.
     * `includeContent(projectPath: String)`, includes only JCR content, example: `includeContent ':example.design'`.
     * `includeBundles(projectPath: String)`, includes only bundles, example: `includeBundles ':example.auth'`.
     * `includeBundlesAtRunMode(projectPath: String, runMode: String)`, as above, useful when bundles need to be installed only on specific type of instance.
+    * `includeSubprojects(withSamePathPrefix: Boolean = true)`, includes both bundles and JCR from all nested subprojects, example: project `:app` will include `:app:common`, `:app:core` etc. Vault filter file will be automatically generated with all filter roots merged. Useful for building assemblies (all-in-one packages).
     * all inherited from [ZIP task](https://docs.gradle.org/3.5/dsl/org.gradle.api.tasks.bundling.Zip.html).
 * `aemUpload` - Upload composed CRX package into AEM instance(s).
 * `aemInstall` - Install uploaded CRX package on AEM instance(s).
@@ -163,6 +164,26 @@ Snippet above demonstrates customizations valid only for specific project.
 -Paem.deploy.skipDownloadName=true
 ```
 
+### Expandable variables
+
+By default, plugin is configured that in all XML files, variables can be injected:
+
+```
+aem {
+    vaultFilesExpanded = ["*.xml"]
+    vaultExpandProperties = [:]
+}
+```
+
+This feature is specially useful to generate valid *META-INF/properties.xml* file.
+What is more, there are predefined variables that also can be used:
+
+* `rootProject` - project with directory in which *settings.gradle* is located.
+* `project` - current project.
+* `config` - [AEM configuration](src/main/kotlin/com/cognifide/gradle/aem/AemConfig.kt).
+* `created` - current date in ISO8601 format.
+* `buildCount` - number to be used as CRX package build count (current date in format `yDDmmssSSS`).
+* `filterRoots` - after using method `includeContent` of `aemCompose` task, Vault filter roots all being gathered. This variable contains all these XML tags concatenated especially useful for building assemblies. If no projects will be included, then this variable will contain a single filter root with bundle install path to be able to deploy auto-generated package with JAR file only.
 
 ## License
 

build.gradle

@@ -6,7 +6,7 @@ plugins {
 }
 
 group 'com.cognifide.gradle'
-version '1.1.2-SNAPSHOT'
+version '1.2.0'
 description = 'Gradle AEM Plugin'
 defaultTasks = ['clean', 'publishToMavenLocal']
 
@@ -28,6 +28,7 @@ dependencies {
     compile 'org.dm.gradle:gradle-bundle-plugin:0.10.0'
     compile 'org.apache.jackrabbit.vault:org.apache.jackrabbit.vault:3.1.26'
     compile 'org.apache.jackrabbit.vault:vault-cli:3.1.6'
+    compile 'org.jsoup:jsoup:1.10.3'
 }
 
 gradlePlugin {

doc/cognifide-logo.png docs/cognifide-logo.pngdoc/cognifide-logo.png renamed to docs/cognifide-logo.png

@@ -42,9 +42,10 @@ data class AemConfig(
     var acHandling: String = "merge_preserve",
 
     /**
-     * Relative to project, path to JCR content to be included in CRX package.
+     * Absolute path to JCR content to be included in CRX package.
+     * Default: "${project.projectDir.path}/src/main/content"
      */
-    var contentPath: String = "src/main/content",
+    var contentPath: String = "",
 
     /**
      * Content path to bundle jars being placed in CRX package.
@@ -173,24 +174,25 @@ data class AemConfig(
             return extended
         }
 
+        fun of(project: Project): AemConfig {
+            return (project.tasks.getByName(ComposeTask.NAME) as AemTask).config
+        }
+
         private fun applyProjectDefaults(config: AemConfig, project: Project) {
-            config.bundlePath = "/apps/" + project.rootProject.name + "/install"
+            if (project.path == project.rootProject.path) {
+                config.bundlePath = "/apps/${project.name}/install"
+            } else {
+                config.bundlePath = "/apps/${project.rootProject.name}/${project.name}/install"
+            }
+
+            config.contentPath = "${project.projectDir.path}/src/main/content"
         }
     }
 
     fun instance(url: String, user: String = "admin", password: String = "admin", type: String = "default") {
         instances.add(AemInstance(url, user, password, type))
     }
 
-    /**
-     * While including another project content, use path configured in that project.
-     */
-    fun determineContentPath(project: Project): String {
-        val task = project.tasks.getByName(ComposeTask.NAME) as ComposeTask
-
-        return project.projectDir.path + "/" + task.config.contentPath
-    }
-
     /**
      * Following checks will be performed during configuration phase
      */

doc/logo.png docs/logo.pngdoc/logo.png renamed to docs/logo.png

@@ -11,8 +11,6 @@ import org.gradle.api.Project
 import org.gradle.api.artifacts.Configuration
 import org.gradle.api.plugins.BasePlugin
 import org.gradle.api.plugins.JavaPlugin
-import org.gradle.api.plugins.JavaPluginConvention
-import org.gradle.api.tasks.SourceSet
 import org.gradle.language.base.plugins.LifecycleBasePlugin
 
 /**
@@ -24,14 +22,14 @@ import org.gradle.language.base.plugins.LifecycleBasePlugin
 class AemPlugin : Plugin<Project> {
 
     companion object {
+        val ID = "cognifide.aem"
+
         val TASK_GROUP = "AEM"
 
         val CONFIG_INSTALL = "aemInstall"
 
         val CONFIG_EMBED = "aemEmbed"
 
-        val CONFIG_SOURCE_SETS = listOf(SourceSet.MAIN_SOURCE_SET_NAME, SourceSet.TEST_SOURCE_SET_NAME)
-
         val VLT_PATH = "META-INF/vault"
 
         val JCR_ROOT = "jcr_root"
@@ -102,41 +100,16 @@ class AemPlugin : Plugin<Project> {
     }
 
     private fun setupConfigs(project: Project) {
-        createConfig(project, CONFIG_INSTALL, JavaPlugin.IMPLEMENTATION_CONFIGURATION_NAME)
-        createConfig(project, CONFIG_EMBED, JavaPlugin.IMPLEMENTATION_CONFIGURATION_NAME)
-    }
-
-    private fun createConfig(project: Project, configName: String, configToBeExtended: String): Configuration {
-        val result = project.configurations.create(configName, {
-            it.isTransitive = false
-        })
-        forConfiguration(project, configToBeExtended, { config ->
-            config.extendsFrom(result)
-            appendConfigurationToCompileClasspath(project, result)
-        })
-
-        return result
-    }
-
-    private fun forConfiguration(project: Project, name: String, creator: (Configuration) -> Unit) {
-        val config = project.configurations.findByName(name)
-        if (config != null) {
-            creator(config)
-        } else {
-            project.configurations.whenObjectAdded {
-                if (it is Configuration) {
-                    if (name == it.name) {
-                        creator(config)
-                    }
-                }
+        project.plugins.withType(JavaPlugin::class.java, {
+            val baseConfig = project.configurations.getByName(JavaPlugin.COMPILE_CONFIGURATION_NAME)
+            val configurer: (Configuration) -> Unit = {
+                it.isTransitive = false
+                baseConfig.extendsFrom(it)
             }
-        }
-    }
-
-    private fun appendConfigurationToCompileClasspath(project: Project, config: Configuration) {
-        val jar = project.convention.getPlugin(JavaPluginConvention::class.java)
 
-        jar.sourceSets.filter { CONFIG_SOURCE_SETS.contains(it.name) }.forEach { it.compileClasspath += config }
+            project.configurations.create(CONFIG_EMBED, configurer)
+            project.configurations.create(CONFIG_INSTALL, configurer)
+        })
     }
 
     private fun setupValidation(project: Project) {

src/main/kotlin/com/cognifide/gradle/aem/AemConfig.kt

@@ -17,6 +17,8 @@ import org.gradle.api.tasks.Internal
 import org.gradle.api.tasks.OutputDirectory
 import org.gradle.api.tasks.TaskAction
 import org.gradle.api.tasks.bundling.Zip
+import org.jsoup.Jsoup
+import org.jsoup.parser.Parser
 import org.reflections.Reflections
 import org.reflections.scanners.ResourcesScanner
 import java.io.File
@@ -31,11 +33,14 @@ open class ComposeTask : Zip(), AemTask {
     }
 
     @Internal
-    var bundleCollectors: MutableMap<String, MutableList<() -> Set<File>>> = mutableMapOf()
+    var bundleCollectors: List<() -> Unit> = mutableListOf()
 
     @Internal
     var contentCollectors: List<() -> Unit> = mutableListOf()
 
+    @Internal
+    private val vaultFilters = mutableListOf<File>()
+
     @OutputDirectory
     private val vaultDir = File(project.buildDir, "$NAME/${AemPlugin.VLT_PATH}")
 
@@ -70,15 +75,7 @@ open class ComposeTask : Zip(), AemTask {
     }
 
     private fun fromBundles() {
-        for ((installPath, jarCollectors) in bundleCollectors) {
-            val jars = jarCollectors.fold(TreeSet<File>(), { files, it -> files.addAll(it()); files })
-            if (jars.isEmpty()) {
-                logger.info("No bundles to copy into AEM package at install path '$installPath'")
-            } else {
-                logger.info("Copying bundles into AEM package at install path '$installPath': " + jars.toString())
-                into("${AemPlugin.JCR_ROOT}/$installPath") { spec -> spec.from(jars) }
-            }
-        }
+        bundleCollectors.onEach { it() }
     }
 
     private fun includeVaultFiles() {
@@ -91,7 +88,7 @@ open class ComposeTask : Zip(), AemTask {
         val contentPath: String = if (!config.vaultFilesPath.isNullOrBlank()) {
             config.vaultFilesPath
         } else {
-            "${config.determineContentPath(project)}/${AemPlugin.VLT_PATH}"
+            "${config.contentPath}/${AemPlugin.VLT_PATH}"
         }
 
         val contentDir = File(contentPath)
@@ -129,6 +126,19 @@ open class ComposeTask : Zip(), AemTask {
         }
     }
 
+    private fun parseVaultFilterRoots(): String {
+        val tags = vaultFilters.filter { it.exists() }.fold(mutableListOf<String>(), { tags, filter ->
+            val doc = Jsoup.parse(filter.bufferedReader().use { it.readText() }, "", Parser.xmlParser())
+            tags.addAll(doc.select("filter[root]").map { it.toString() }.toList()); tags
+        })
+
+        if (tags.isEmpty()) {
+            tags.add("<filter root=\"${config.bundlePath}\"/>")
+        }
+
+        return tags.joinToString(config.vaultLineSeparator)
+    }
+
     private fun expandVaultFiles() {
         val files = vaultDir.listFiles { _, name -> config.vaultFilesExpanded.any { FilenameUtils.wildcardMatch(name, it, IOCase.INSENSITIVE) } } ?: return
 
@@ -156,55 +166,95 @@ open class ComposeTask : Zip(), AemTask {
                 "project" to project,
                 "config" to config,
                 "created" to ISO8601Utils.format(now),
-                "buildCount" to SimpleDateFormat("yDDmmssSSS").format(now)
+                "buildCount" to SimpleDateFormat("yDDmmssSSS").format(now),
+                "filterRoots" to parseVaultFilterRoots()
         ))
-
         return template.toString()
     }
 
     private fun fromContents() {
         contentCollectors.onEach { it() }
     }
 
+    fun includeSubprojects() {
+        includeSubprojects(true)
+    }
+
+    fun includeSubprojects(withSamePathPrefix: Boolean) {
+        project.gradle.afterProject { subproject ->
+            if (subproject.path != project.path && subproject.plugins.hasPlugin(AemPlugin.ID)) {
+                if (!withSamePathPrefix || subproject.path.startsWith("${project.path}:")) {
+                    includeProject(subproject)
+                }
+            }
+        }
+    }
+
     fun includeProject(projectPath: String) {
         includeProject(project.findProject(projectPath))
     }
 
     fun includeProject(project: Project) {
         includeContent(project)
-        includeBundles(project, config.bundlePath)
+        includeBundles(project)
     }
 
     fun includeBundles(projectPath: String) {
-        includeBundles(project.findProject(projectPath), config.bundlePath)
+        val project = project.findProject(projectPath)
+
+        includeBundles(project, AemConfig.of(project).bundlePath)
+    }
+
+    fun includeBundles(project: Project) {
+        includeBundles(project, AemConfig.of(project).bundlePath)
     }
 
     fun includeBundles(projectPath: String, installPath: String) {
         includeBundles(project.findProject(projectPath), installPath)
     }
 
-    fun includeBundlesAtRunMode(projectPath: String, runMode : String) {
+    fun includeBundlesAtRunMode(projectPath: String, runMode: String) {
         val project = project.findProject(projectPath)
-        includeBundles(project, "${config.bundlePath}.$runMode")
+        val bundlePath = AemConfig.of(project).bundlePath
+
+        includeBundles(project, "$bundlePath.$runMode")
     }
 
     fun includeBundles(project: Project, installPath: String) {
+        val config = AemConfig.of(project)
+
         dependProject(project, config.dependBundlesTaskNames(project))
 
-        bundleCollectors.getOrPut(installPath, { mutableListOf() }).add({
-            JarCollector(project).all.toSet()
-        })
+        bundleCollectors += {
+            val jars = JarCollector(project).all.toSet()
+
+            if (jars.isEmpty()) {
+                logger.info("No bundles to copy into AEM package at install path '$installPath'")
+            } else {
+                logger.info("Copying bundles into AEM package at install path '$installPath': " + jars.toString())
+
+                into("${AemPlugin.JCR_ROOT}/$installPath") { spec ->
+                    spec.from(jars)
+                }
+            }
+        }
     }
 
     fun includeContent(projectPath: String) {
         includeContent(project.findProject(projectPath))
     }
 
     fun includeContent(project: Project) {
+        val config = AemConfig.of(project)
+
         dependProject(project, config.dependContentTaskNames(project))
 
+        if (this.project.path != project.path) {
+            vaultFilters.add(project.file(config.vaultFilterPath))
+        }
+
         contentCollectors += {
-            val contentDir = File("${config.determineContentPath(project)}/${AemPlugin.JCR_ROOT}")
+            val contentDir = File("${config.contentPath}/${AemPlugin.JCR_ROOT}")
             if (!contentDir.exists()) {
                 logger.info("Package JCR content directory does not exist: ${contentDir.absolutePath}")
             } else {
@@ -218,11 +268,11 @@ open class ComposeTask : Zip(), AemTask {
         }
     }
 
-    fun dependProject(projectPath: String, taskNames : Set<String>) {
+    fun dependProject(projectPath: String, taskNames: Set<String>) {
         dependProject(project.findProject(projectPath), taskNames)
     }
 
-    fun dependProject(project: Project, taskNames : Set<String>) {
+    fun dependProject(project: Project, taskNames: Set<String>) {
         taskNames.forEach { taskName -> dependsOn("${project.path}:$taskName") }
     }