Refactor StringCarePlugin and related extensions for improved configuration handling: replace direct configuration access with effective methods, enhance variant obfuscation task registration, and streamline project path retrieval.

Author: efraespada

plugin/src/main/kotlin/dev/vyp/stringcare/plugin/StringCarePlugin.kt

@@ -30,10 +30,11 @@ class StringCarePlugin : Plugin<Project> {
         val buildService = registerStringCareService(target)
 
         target.plugins.withId("com.android.application") {
-            val config = target.config(extension)
-            buildService.get().setResolvedConfiguration(config)
-            target.registerVariantObfuscationTasks(config, buildService)
+            val bookkeeping = target.config(extension)
+            buildService.get().setResolvedConfiguration(bookkeeping)
+            target.registerVariantObfuscationTasks(bookkeeping, extension, buildService)
             target.afterEvaluate {
+                buildService.get().setResolvedConfiguration(target.config(extension))
                 val resolved = buildService.get().getResolvedConfiguration()
                 if (resolved.debug) {
                     PrintUtils.print("PATH", buildService.get().absoluteProjectPath())

plugin/src/main/kotlin/dev/vyp/stringcare/plugin/internal/Extensions.kt

@@ -121,15 +121,15 @@ fun File.validForXMLConfiguration(configuration: StringCareConfiguration): Boole
             excludedForXML().not()
     if (valid) {
         valid = false
-        configuration.srcFolders.forEach { folder ->
+        configuration.effectiveSrcFolders().forEach { folder ->
             if (pathContains(this.absolutePath, folder)) {
                 valid = true
             }
         }
     }
     if (valid) {
         valid = false
-        configuration.stringFiles.forEach { file ->
+        configuration.effectiveStringFiles().forEach { file ->
             if (pathEndsWith(this.absolutePath, file)) {
                 valid = true
             }
@@ -194,15 +194,15 @@ fun File.resourceFile(configuration: StringCareConfiguration): ResourceFile? {
     var sourceFolder = ""
     var validFile: File? = null
     var valid = false
-    configuration.srcFolders.forEach { folder ->
+    configuration.effectiveSrcFolders().forEach { folder ->
         if (pathContains(this.absolutePath, folder)) {
             sourceFolder = folder
             valid = true
         }
     }
     if (valid) {
         valid = false
-        configuration.stringFiles.forEach { file ->
+        configuration.effectiveStringFiles().forEach { file ->
             if (pathEndsWith(this.absolutePath, file)) {
                 valid = true
                 validFile = this
@@ -217,7 +217,7 @@ fun File.assetsFile(configuration: StringCareConfiguration): AssetsFile? {
     var sourceFolder = ""
     var validFile: File? = null
     var valid = false
-    configuration.srcFolders.forEach { folder ->
+    configuration.effectiveSrcFolders().forEach { folder ->
         if (pathContains(this.absolutePath, folder)) {
             sourceFolder = folder
             valid = true
@@ -334,3 +334,10 @@ fun StringCareConfiguration.normalize(): StringCareConfiguration {
     srcFolders.addAll(nextSrc)
     return this
 }
+
+/** Defaults must match [locateConfiguredFiles] / Variant task includes when lists were not merged from DSL yet. */
+internal fun StringCareConfiguration.effectiveSrcFolders(): List<String> =
+    srcFolders.takeIf { it.isNotEmpty() } ?: listOf("src/main")
+
+internal fun StringCareConfiguration.effectiveStringFiles(): List<String> =
+    stringFiles.takeIf { it.isNotEmpty() } ?: listOf("strings.xml")

plugin/src/main/kotlin/dev/vyp/stringcare/plugin/internal/ProjectExtensions.kt

@@ -14,15 +14,8 @@ import org.gradle.api.Task
 import org.gradle.api.provider.Provider
 import java.io.File
 
-fun Project.absolutePath(): String {
-    val fPath =
-        this.file("build.gradle").absolutePath.replace(
-            "build.gradle",
-            emptyChar,
-        )
-    val pathComponents = fPath.split(File.separator)
-    return fPath.replace(pathComponents[pathComponents.size - 2] + File.separator, "")
-}
+/** Root directory of this Gradle project (the module applying the plugin). */
+fun Project.absolutePath(): String = projectDir.absolutePath
 
 fun Project.module(): String {
     val fPath =

plugin/src/main/kotlin/dev/vyp/stringcare/plugin/internal/VariantApi.kt

@@ -2,6 +2,7 @@ package dev.vyp.stringcare.plugin.internal
 
 import com.android.build.api.variant.ApplicationAndroidComponentsExtension
 import dev.vyp.stringcare.plugin.StringCareConfiguration
+import dev.vyp.stringcare.plugin.StringCareExtension
 import dev.vyp.stringcare.plugin.services.StringCareBuildService
 import dev.vyp.stringcare.plugin.tasks.ObfuscateAssetsTask
 import dev.vyp.stringcare.plugin.tasks.ObfuscateStringsTask
@@ -16,23 +17,21 @@ import org.gradle.api.tasks.TaskCollection
 private fun String.variantTaskSuffix(): String = replaceFirstChar { it.uppercase() }
 
 fun Project.registerVariantObfuscationTasks(
-    config: StringCareConfiguration,
+    bookkeeping: StringCareConfiguration,
+    extension: StringCareExtension,
     buildService: Provider<StringCareBuildService>,
 ) {
     val androidComponents =
         extensions.findByType(ApplicationAndroidComponentsExtension::class.java)
             ?: return
 
     val absoluteProjectPath = buildService.get().absoluteProjectPath()
-    val moduleNameValue = config.name
-    val srcJson = toJsonStringList(config.srcFolders)
-    val strJson = toJsonStringList(config.stringFiles)
-    val assetsJson = toJsonStringList(config.assetsFiles)
+    val moduleNameValue = bookkeeping.name
     androidComponents.onVariants(androidComponents.selector().all()) { variant ->
         val variantName: String = variant.name
         val applicationId = variant.applicationId.get()
         buildService.get().putVariantApplicationId(variantName, applicationId)
-        if (config.applicationId.isEmpty()) config.applicationId = applicationId
+        if (bookkeeping.applicationId.isEmpty()) bookkeeping.applicationId = applicationId
         val variantCapitalized = variantName.variantTaskSuffix()
 
         tasks.register(
@@ -45,24 +44,26 @@ fun Project.registerVariantObfuscationTasks(
             t.moduleName.set(moduleNameValue)
             t.variantName.set(variantName)
             t.applicationId.set(applicationId)
-            t.skip.set(config.skip)
-            t.debug.set(config.debug)
-            t.mockedFingerprint.set(config.mockedFingerprint)
-            t.srcFoldersJson.set(srcJson)
-            t.stringFilesJson.set(strJson)
-            t.assetsFilesJson.set(assetsJson)
-            val includes =
-                config.srcFolders
-                    .ifEmpty { listOf("src/main/res") }
-                    .flatMap { src ->
-                        config.stringFiles
-                            .ifEmpty { listOf("strings.xml") }
-                            .map { name -> "$src/**/$name" }
-                    }
+            t.skip.set(provider { extension.skip })
+            t.debug.set(provider { extension.debug })
+            t.mockedFingerprint.set(provider { extension.mockedFingerprint })
+            t.srcFoldersJson.set(provider { toJsonStringList(extension.srcFolders) })
+            t.stringFilesJson.set(provider { toJsonStringList(extension.stringFiles) })
+            t.assetsFilesJson.set(provider { toJsonStringList(extension.assetsFiles) })
             t.xmlInputFiles.from(
-                fileTree(absoluteProjectPath).matching { pattern ->
-                    pattern.include(includes)
-                    pattern.exclude("**/build/**", "**/.git/**", "**/.gradle/**", "**/node_modules/**")
+                provider {
+                    val includes =
+                        extension.srcFolders
+                            .ifEmpty { listOf("src/main/res") }
+                            .flatMap { src ->
+                                extension.stringFiles
+                                    .ifEmpty { listOf("strings.xml") }
+                                    .map { name -> "$src/**/$name" }
+                            }
+                    fileTree(absoluteProjectPath).matching { pattern ->
+                        includes.forEach { pattern.include(it) }
+                        pattern.exclude("**/build/**", "**/.git/**", "**/.gradle/**", "**/node_modules/**")
+                    }
                 },
             )
             t.outputDirectory.set(layout.buildDirectory.dir("stringcare/obfuscate-strings/$variantName"))
@@ -75,7 +76,7 @@ fun Project.registerVariantObfuscationTasks(
             t.stringCareService.set(buildService)
             t.projectPath.set(absoluteProjectPath)
             t.moduleName.set(moduleNameValue)
-            t.skip.set(config.skip)
+            t.skip.set(provider { extension.skip })
         }
 
         tasks.register(
@@ -88,12 +89,12 @@ fun Project.registerVariantObfuscationTasks(
             t.moduleName.set(moduleNameValue)
             t.variantName.set(variantName)
             t.applicationId.set(applicationId)
-            t.skip.set(config.skip)
-            t.debug.set(config.debug)
-            t.mockedFingerprint.set(config.mockedFingerprint)
-            t.srcFoldersJson.set(srcJson)
-            t.stringFilesJson.set(strJson)
-            t.assetsFilesJson.set(assetsJson)
+            t.skip.set(provider { extension.skip })
+            t.debug.set(provider { extension.debug })
+            t.mockedFingerprint.set(provider { extension.mockedFingerprint })
+            t.srcFoldersJson.set(provider { toJsonStringList(extension.srcFolders) })
+            t.stringFilesJson.set(provider { toJsonStringList(extension.stringFiles) })
+            t.assetsFilesJson.set(provider { toJsonStringList(extension.assetsFiles) })
         }
         tasks.register(
             "stringcareAfterMergeAssets$variantCapitalized",
@@ -103,7 +104,7 @@ fun Project.registerVariantObfuscationTasks(
             t.stringCareService.set(buildService)
             t.projectPath.set(absoluteProjectPath)
             t.moduleName.set(moduleNameValue)
-            t.skip.set(config.skip)
+            t.skip.set(provider { extension.skip })
         }
 
         val mergeRes =