Add ruleClass api for priority override (#52)

Author: emilyyuan03

.gitignore

@@ -1,9 +1,10 @@
 .gradle/
+.kotlin/
 build/
 
 .idea/
 *.ipr
 *.iml
 *.iws
 out/
-.obsidian/
+.obsidian/

README.md

@@ -166,15 +166,20 @@ The default threshold is MEDIUM.
 
 #### Overriding rule priority
 
-You can override the default priority of a rule using the `ruleName` and priority as `LOW`, `MEDIUM`, or `HIGH`:
+You can override the default priority of a rule using the `ruleClass` or `ruleName` and `priority` as `LOW`, `MEDIUM`, or `HIGH`:
 ```kotlin
 archRules {
-    rule("deprecated") {
+    ruleClass("com.netflix.nebula.archrules.deprecation") {
         priority("HIGH")
     }
+    ruleName("deprecated") {
+        priority("LOW")
+    }
 }
 ```
 
+The `ruleName` will take precedent over the `ruleClass`.
+
 #### Configuring which code is tested
 
 You can skip running rules on a specific source set:

nebula-archrules-gradle-plugin/src/main/java/com/netflix/nebula/archrules/gradle/RunRulesParams.java

@@ -14,5 +14,7 @@ public interface RunRulesParams extends WorkParameters {
 
     Property<@NonNull File> getDataOutputFile();
 
-    MapProperty<@NonNull String, @NonNull Priority> getPriorityOverrides();
+    MapProperty<@NonNull String, @NonNull Priority> getPriorityOverridesByName();
+
+    MapProperty<@NonNull String, @NonNull Priority> getPriorityOverridesByClass();
 }

nebula-archrules-gradle-plugin/src/main/java/com/netflix/nebula/archrules/gradle/RunRulesWorkAction.java

@@ -34,17 +34,28 @@ public void execute() {
         final var classesToCheck = new ClassFileImporter()
                 .importPaths(getParameters().getClassesToCheck().getFiles().stream().map(File::toPath).toList());
         final List<RuleResult> violationList = new ArrayList<>();
-        final var overrides = getParameters().getPriorityOverrides().getOrElse(Map.of());
+        final var overridesByName = getParameters().getPriorityOverridesByName().getOrElse(Map.of());
+        final var overridesByClass = getParameters().getPriorityOverridesByClass().getOrElse(Map.of());
+
         ruleClasses.forEach(ruleClass -> ruleClass.getRules().forEach((id, archRule) -> {
             final var result = Runner.check(archRule, classesToCheck);
 
-            // check if there is a priority override
+            // check if there is priority override by class first
             var priority = result.getPriority();
-            if (overrides.containsKey(id)) {
-                priority = overrides.get(id);
+            String ruleClassName = ruleClass.getClass().getCanonicalName();
+            for (Map.Entry<String, Priority> override : overridesByClass.entrySet()) {
+                String overrideRuleName = override.getKey();
+                if (ruleClassName.startsWith(overrideRuleName)) {
+                    priority = override.getValue();
+                    break;
+                }
+            }
+            // then check if there is a priority override by name
+            if (overridesByName.containsKey(id)) {
+                priority = overridesByName.get(id);
             }
 
-            final var rule = new Rule(ruleClass.getClass().getCanonicalName(), id, archRule.getDescription(), priority);
+            final var rule = new Rule(ruleClassName, id, archRule.getDescription(), priority);
             if (result.hasViolation()) {
                 result.getFailureReport().getDetails().forEach(detail -> {
                     if (detail.equals(NO_MATCH_MESSAGE)) {

nebula-archrules-gradle-plugin/src/main/kotlin/com/netflix/nebula/archrules/gradle/ArchrulesExtension.kt

@@ -24,7 +24,8 @@ abstract class ArchrulesExtension {
     /**
      * Allow priority overrides
      */
-    abstract val priorityOverrides: MapProperty<String, Priority>
+    abstract val priorityOverridesByRuleName: MapProperty<String, Priority>
+    abstract val priorityOverridesByRuleClass: MapProperty<String, Priority>
 
     /**
      * Add a source set to the list of sourcesets to skip
@@ -49,12 +50,31 @@ abstract class ArchrulesExtension {
         consoleDetailsThreshold.set(Priority.valueOf(priority))
     }
 
+    @Deprecated("use ruleName instead")
     fun rule(ruleName: String, action: Action<RuleConfig>) {
         val config = RuleConfig()
         action.execute(config)
 
         config.priority?.let { priority ->
-            priorityOverrides.put(ruleName, priority)
+            priorityOverridesByRuleName.put(ruleName, priority)
+        }
+    }
+
+    fun ruleName(ruleName: String, action: Action<RuleConfig>) {
+        val config = RuleConfig()
+        action.execute(config)
+
+        config.priority?.let { priority ->
+            priorityOverridesByRuleName.put(ruleName, priority)
+        }
+    }
+
+    fun ruleClass(ruleClass: String, action: Action<RuleConfig>) {
+        val config = RuleConfig()
+        action.execute(config)
+
+        config.priority?.let { priority ->
+            priorityOverridesByRuleClass.put(ruleClass, priority)
         }
     }
 }

nebula-archrules-gradle-plugin/src/main/kotlin/com/netflix/nebula/archrules/gradle/ArchrulesRunnerPlugin.kt

@@ -90,7 +90,8 @@ class ArchrulesRunnerPlugin : Plugin<Project> {
         tasks.register<CheckRulesTask>("checkArchRules" + sourceSet.name.capitalized()) {
             description = "Checks ArchRules on ${sourceSet.name}"
             rulesClasspath.setFrom(sourceSetArchRulesRuntime)
-            priorityOverrides.set(ext.priorityOverrides)
+            priorityOverridesByName.set(ext.priorityOverridesByRuleName)
+            priorityOverridesByClass.set(ext.priorityOverridesByRuleClass)
             dataFile.set(archRulesReportDir.map {
                 it.file(sourceSet.name + ".data").asFile
             })
@@ -100,4 +101,4 @@ class ArchrulesRunnerPlugin : Plugin<Project> {
             onlyIf { !ext.sourceSetsToSkip.get().contains(sourceSetName) }
         }
     }
-}
+}

nebula-archrules-gradle-plugin/src/main/kotlin/com/netflix/nebula/archrules/gradle/CheckRulesTask.kt

@@ -27,7 +27,10 @@ abstract class CheckRulesTask @Inject constructor(private val workerExecutor: Wo
     abstract val dataFile: Property<File>
 
     @get:Input
-    abstract val priorityOverrides: MapProperty<String, Priority>
+    abstract val priorityOverridesByName: MapProperty<String, Priority>
+
+    @get:Input
+    abstract val priorityOverridesByClass: MapProperty<String, Priority>
 
     @TaskAction
     fun checkRules() {
@@ -37,7 +40,8 @@ abstract class CheckRulesTask @Inject constructor(private val workerExecutor: Wo
         workQueue.submit(RunRulesWorkAction::class) {
             getClassesToCheck().from(sourcesToCheck)
             getDataOutputFile().set(dataFile)
-            getPriorityOverrides().set(this@CheckRulesTask.priorityOverrides)
+            getPriorityOverridesByName().set(this@CheckRulesTask.priorityOverridesByName)
+            getPriorityOverridesByClass().set(this@CheckRulesTask.priorityOverridesByClass)
         }
     }
 }

nebula-archrules-gradle-plugin/src/test/kotlin/com/netflix/nebula/archrules/gradle/ArchrulesRunnerPluginTest.kt

@@ -466,15 +466,18 @@ archRules {
     }
 
     @Test
-    fun `can override priority of a rule`() {
+    fun `can override priority of a rule using both rule class and name`() {
         val runner = testProject(projectDir) {
             setupConsumerProject {
                 rawBuildScript(
                     """
 archRules {
-    rule("deprecated") {
+    ruleClass("com.netflix.nebula.archrules.deprecation") {
         priority("HIGH")
     }
+    ruleName("deprecated") {
+        priority("MEDIUM")
+    }
 }
 """
                 )
@@ -490,17 +493,17 @@ archRules {
         val mainReport = projectDir.resolve("build/reports/archrules/main.data")
         val results = readDetails(mainReport)
 
-        // assert deprecated (LOW) is overridden
+        val deprecatedForRemovalResults = results.filter { it.rule.ruleName.equals("deprecatedForRemoval") }
+        assertThat(deprecatedForRemovalResults).hasSize(1)
+        deprecatedForRemovalResults.forEach { result ->
+            assertThat(result.rule.priority).isEqualTo(Priority.HIGH)
+        }
+
         val deprecatedResults = results.filter { it.rule.ruleName.equals("deprecated") }
         assertThat(deprecatedResults).hasSize(2)
         deprecatedResults.forEach { result ->
-            assertThat(result.rule.priority).isEqualTo(Priority.HIGH)
+            assertThat(result.rule.priority).isEqualTo(Priority.MEDIUM)
         }
-
-        // assert deprecatedForRemoval (MEDIUM), which is in the same class but not the same rule, is not overridden
-        val deprecatedForRemovalResult = results.firstOrNull { it.rule.ruleName.equals("deprecatedForRemoval") }
-        assertThat(deprecatedForRemovalResult).isNotNull
-        assertThat(deprecatedForRemovalResult!!.rule.priority).isEqualTo(Priority.MEDIUM)
     }
 
     @Test
@@ -510,7 +513,7 @@ archRules {
                 rawBuildScript(
                     """
 archRules {
-    rule("deprecatedForRemoval") {
+    ruleName("deprecatedForRemoval") {
         priority("NONE")
     }
 }