Remove unused dependencyRulesApplied and make jackson object mapper lazy

Author: rpalcolea

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

@@ -70,7 +70,7 @@ class AlignMatcher(val rule: AlignRule, groupPattern: Pattern, includesPatterns:
 }
 
 //@CacheableRule
-open abstract class AlignedPlatformMetadataRule @Inject constructor(val rule: AlignRule) : ComponentMetadataRule, Serializable {
+abstract class AlignedPlatformMetadataRule @Inject constructor(val rule: AlignRule) : ComponentMetadataRule, Serializable {
     private val logger: Logger = Logging.getLogger(AlignedPlatformMetadataRule::class.java)
 
     override fun execute(componentMetadataContext: ComponentMetadataContext) {

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

@@ -19,6 +19,8 @@ package nebula.plugin.resolutionrules
 import com.fasterxml.jackson.databind.*
 import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
 
-fun objectMapper(): ObjectMapper {
-    return jacksonObjectMapper()
-}
+/**
+ * Lazily initialized, shared ObjectMapper instance for JSON deserialization.
+ * Thread-safe singleton that is only created when first accessed.
+ */
+val objectMapper: ObjectMapper by lazy { jacksonObjectMapper() }

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

@@ -107,7 +107,6 @@ class ResolutionRulesPlugin : Plugin<Project> {
                 return@configureEach
             }
 
-            var dependencyRulesApplied = false
             project.onExecute {
                 val ruleSet = extension.ruleSet()
                 when {
@@ -122,7 +121,6 @@ class ResolutionRulesPlugin : Plugin<Project> {
                         ruleSet.dependencyRulesPartTwo().forEach { rule ->
                             rule.apply(project, config, config.resolutionStrategy, extension)
                         }
-                        dependencyRulesApplied = true
                     }
                 }
             }
@@ -150,7 +148,11 @@ class ResolutionRulesPlugin : Plugin<Project> {
 abstract class NebulaResolutionRulesService : BuildService<NebulaResolutionRulesService.Params> {
     companion object {
         private val Logger: Logger = Logging.getLogger(NebulaResolutionRulesService::class.java)
-        private val Mapper = objectMapper()
+        private val Mapper = objectMapper
+
+        private const val JSON_EXTENSION = "json"
+        private const val JAR_EXTENSION = "jar"
+        private const val ZIP_EXTENSION = "zip"
 
         fun registerService(project: Project): Provider<NebulaResolutionRulesService> {
             return project.gradle.sharedServices.registerIfAbsent(
@@ -167,18 +169,18 @@ abstract class NebulaResolutionRulesService : BuildService<NebulaResolutionRules
             configuration.incoming.files.files.stream().use { stream ->
                 return stream.flatMap { file ->
                     when (file.extension) {
-                        "json" -> {
+                        JSON_EXTENSION -> {
                             Logger.debug("nebula.resolution-rules uses: {}", file.name)
                             Stream.of(file.absolutePath to file.readBytes())
                         }
-                        "jar", "zip" -> {
+                        JAR_EXTENSION, ZIP_EXTENSION -> {
                             Logger.info("nebula.resolution-rules is using ruleset: {}", file.name)
                             val zipFile = ZipFile(file)
                             Collections.list(zipFile.entries()).stream()
                                 .onClose(zipFile::close)
                                 .flatMap { entry ->
                                     val entryFile = File(entry.name)
-                                    if (entryFile.extension == "json") {
+                                    if (entryFile.extension == JSON_EXTENSION) {
                                         Stream.of("${file.absolutePath}!${entry.name}" to zipFile.getInputStream(entry).readBytes())
                                     } else Stream.empty()
                                 }
@@ -190,7 +192,7 @@ abstract class NebulaResolutionRulesService : BuildService<NebulaResolutionRules
                     }
                 }.parallel()
                     .map { (path, bytes) ->
-                        val filePath = if (path.contains("!")) path.substringAfter("!") else path
+                        val filePath = path.substringAfterLast('!', path)
                         val file = File(filePath)
                         val ruleSetName = file.nameWithoutExtension
                         Logger.debug("Using {} ({}) a dependency rules source", ruleSetName, path)

src/test/groovy/nebula/plugin/resolutionrules/RulesTest.groovy

@@ -73,7 +73,7 @@ class RulesTest extends Specification {
     }
 
     static RuleSet parseJsonText(String json) {
-        def ruleSet = JsonKt.objectMapper().readValue(json, RuleSet)
+        def ruleSet = JsonKt.getObjectMapper().readValue(json, RuleSet)
         return RulesKt.withName(ruleSet, "dummy")
     }
 }