NebulaResolutionRulesExtension: allow to configure include,exclude and optional through project properties

Author: rpalcolea

src/integTest/groovy/nebula/plugin/resolutionrules/ResolutionRulesPluginSpec.groovy

@@ -330,6 +330,28 @@ class ResolutionRulesPluginSpec extends AbstractIntegrationTestKitSpec {
         result.output.contains '\\--- org.slf4j:slf4j-api:1.7.21\n'
     }
 
+    def 'optional rules are applied when specified through project properties'() {
+        given:
+        buildFile << """
+                     dependencies {
+                         resolutionRules files("$optionalRulesJsonFile")
+
+                         implementation 'log4j:log4j:1.2.17'
+                         implementation 'org.slf4j:jcl-over-slf4j:1.7.0'
+                     }
+                     """.stripIndent()
+
+
+        when:
+        def result = runTasks('dependencies', '--configuration', 'compileClasspath', "-PnebulaResolutionRules.optional=${moduleName}")
+
+        then:
+        result.output.contains '+--- log4j:log4j:1.2.17 -> org.slf4j:log4j-over-slf4j:1.7.21\n'
+        result.output.contains '|    \\--- org.slf4j:slf4j-api:1.7.21\n'
+        result.output.contains '\\--- org.slf4j:jcl-over-slf4j:1.7.0 -> 1.7.21\n'
+        result.output.contains '\\--- org.slf4j:slf4j-api:1.7.21\n'
+    }
+
     def 'only included rules are applied'() {
         given:
         def otherRulesFile = new File(projectDir, "other-${moduleName}.json")
@@ -369,6 +391,41 @@ class ResolutionRulesPluginSpec extends AbstractIntegrationTestKitSpec {
         !result.output.contains('asm:asm:3.3.1 -> org.ow2.asm:asm:5.0.4')
     }
 
+    def 'only included rules are applied via project properties'() {
+        given:
+        def otherRulesFile = new File(projectDir, "other-${moduleName}.json")
+        otherRulesFile << """
+                                    {
+                                        "substitute" : [
+                                            {
+                                                "module" : "log4j:log4j",
+                                                "with" : "org.slf4j:log4j-over-slf4j:1.7.21",
+                                                "reason" : "SLF4J bridge replacement",
+                                                "author" : "Danny Thomas <[email protected]>",
+                                                "date" : "2015-10-07T20:21:20.368Z"
+                                            }
+                                        ]
+                                    }
+                                 """
+        buildFile << """
+                     dependencies {
+                         resolutionRules files("$optionalRulesJsonFile", "$otherRulesFile")
+
+                         implementation 'log4j:log4j:1.2.17'
+                         implementation 'asm:asm:3.3.1'
+                         implementation 'org.ow2.asm:asm:5.0.4'
+                     }
+                     """.stripIndent()
+
+
+        when:
+        def result = runTasks('dependencies', '--configuration', 'compileClasspath', "-PnebulaResolutionRules.include=other-${moduleName}")
+
+        then:
+        result.output.contains('log4j:log4j:1.2.17 -> org.slf4j:log4j-over-slf4j:1.7.21')
+        !result.output.contains('asm:asm:3.3.1 -> org.ow2.asm:asm:5.0.4')
+    }
+
     @Unroll
     def "deny dependency"() {
         given:

src/main/kotlin/nebula/plugin/resolutionrules/extensions.kt

@@ -1,5 +1,12 @@
 package nebula.plugin.resolutionrules
 
+import org.gradle.api.Project
+
 inline fun <T, R> Collection<T>.mapToSet(transform: (T) -> R): Set<R> {
     return mapTo(LinkedHashSet<R>(size), transform)
 }
+
+fun Project.findStringProperty(name: String): String? = if (hasProperty(name)) property(name) as String? else null
+
+fun parseRuleNames(ruleNames: String): Set<String> =
+    ruleNames.split(",").map { it.trim() }.filter { it.isNotEmpty()} .toSet()

src/main/kotlin/nebula/plugin/resolutionrules/plugin.kt

@@ -68,14 +68,17 @@ class ResolutionRulesPlugin : Plugin<Project> {
         const val BOOT_ARCHIVES_CONFIGURATION_NAME = "bootArchives"
         const val ARCHIVES_CONFIGURATION_NAME = "archives"
         const val OPTIONAL_PREFIX = "optional-"
+        const val OPTIONAL_RULES_PROJECT_PROPERTY = "nebulaResolutionRules.optional"
+        const val INCLUDE_RULES_PROJECT_PROPERTY = "nebulaResolutionRules.include"
+        const val EXCLUDE_RULES_PROJECT_PROPERTY = "nebulaResolutionRules.exclude"
     }
 
     override fun apply(project: Project) {
         this.project = project
         configurations = project.configurations
         extension =
             project.extensions.create("nebulaResolutionRules", NebulaResolutionRulesExtension::class.java, project)
-
+        addRulesFromProjectProperties(project, extension)
         val rootProject = project.rootProject
         val configuration = project.configurations.maybeCreate(RESOLUTION_RULES_CONFIG_NAME)
         if (project != rootProject) {
@@ -126,6 +129,22 @@ class ResolutionRulesPlugin : Plugin<Project> {
         }
     }
 
+    /**
+     * Search for optional, include and exclude rules in project properties
+     * Add them to the extension if found
+     */
+    private fun addRulesFromProjectProperties(
+        project: Project,
+        extension: NebulaResolutionRulesExtension
+    ) {
+        val optionalRules = project.findStringProperty(OPTIONAL_RULES_PROJECT_PROPERTY)
+        optionalRules?.let { rules -> parseRuleNames(rules).forEach { extension.optional.add(it) } }
+        val includeRules = project.findStringProperty(INCLUDE_RULES_PROJECT_PROPERTY)
+        includeRules?.let { rules -> parseRuleNames(rules).forEach { extension.include.add(it) } }
+        val excludeRules = project.findStringProperty(EXCLUDE_RULES_PROJECT_PROPERTY)
+        excludeRules?.let { rules -> parseRuleNames(rules).forEach { extension.exclude.add(it) } }
+    }
+
 }
 
 abstract class NebulaResolutionRulesService : BuildService<NebulaResolutionRulesService.Params> {