refactor: make similar code more similar. Add comments.

Author: autonomousapps

src/main/kotlin/com/autonomousapps/internal/analyzer/AndroidSources.kt

@@ -82,13 +82,16 @@ internal open class DefaultAndroidSources(
       ?: project.provider { emptyList() }
   }
 
+  // nb: android res is a superset of layouts. This means layouts will get parsed twice. This is currently simpler than
+  // rewriting a bunch of code (the two parsers look for different things).
   override fun getAndroidRes(): Provider<Iterable<File>> {
     // https://github.com/autonomousapps/dependency-analysis-gradle-plugin/issues/1112
     // https://issuetracker.google.com/issues/325307775
     return try {
       sources.res?.all
         ?.map { layers -> layers.flatten() }
         ?.map { directories ->
+          // Sometimes there's weird nonsense in the layout directories
           directories.map { directory -> directory.asFileTree.matching(Language.filterOf(Language.XML)) }
         }
         ?.map { trees -> trees.flatten() }
@@ -105,13 +108,14 @@ internal open class DefaultAndroidSources(
       sources.res?.all
         ?.map { layers -> layers.flatten() }
         ?.map { directories -> directories.map { directory -> directory.asFileTree } }
-        ?.map { fileTrees ->
-          fileTrees.map { fileTree ->
-            fileTree.matching {
+        ?.map { trees ->
+          trees.map { tree ->
+            tree.matching {
               include("**/layout/**/*.xml")
             }
-          }.flatten()
+          }
         }
+        ?.map { trees -> trees.flatten() }
         ?: project.provider { emptyList() }
     } catch (_: Exception) {
       project.provider { emptyList() }

src/main/kotlin/com/autonomousapps/internal/parse/explodeAndroidResSource.kt

@@ -20,7 +20,7 @@ import java.io.File
 
 internal class AndroidLayoutParser(
   private val projectDir: File,
-  private val layouts: Set<File>,
+  private val layouts: Iterable<File>,
 ) {
 
   val explodedLayouts: Set<ExplodedLayout> = parseLayouts()
@@ -31,7 +31,8 @@ internal class AndroidLayoutParser(
         layoutFile to buildDocument(layoutFile).getElementsByTagName("*")
           .map { it.nodeName }
           .filterToOrderedSet { JAVA_FQCN_REGEX_DOTTY.matches(it) }
-      }.map { (file, classes) ->
+      }
+      .map { (file, classes) ->
         ExplodedLayout(
           relativePath = file.toRelativeString(projectDir),
           usedClasses = classes
@@ -55,7 +56,7 @@ internal class AndroidResParser(
 
   private val container = Container()
 
-  val androidResSource: Set<ExplodedRes> = resources
+  val androidResSource: Set<ExplodedRes> = resources.asSequence()
     .mapNotNull {
       try {
         it to buildDocument(it)
@@ -64,7 +65,7 @@ internal class AndroidResParser(
         null
       }
     }
-    .mapToSet { (file, doc) ->
+    .map { (file, doc) ->
       // Populate the container
       extractAttrsFromResourceXml(doc)
       extractContentReferencesFromResourceXml(doc)
@@ -75,14 +76,17 @@ internal class AndroidResParser(
         attrRefs = container.nonLocalAttrRefs()
       )
     }
+    .toSet()
 
   // e.g., "Theme.AppCompat.Light.DarkActionBar"
   private fun extractStyleParentsFromResourceXml(doc: Document): Set<AndroidResSource.StyleParentRef> =
-    doc.getElementsByTagName("style").mapNotNull {
-      it.attributes.getNamedItem("parent")?.nodeValue
-    }.mapToSet {
-      AndroidResSource.StyleParentRef.of(it)
-    }
+    doc.getElementsByTagName("style")
+      .mapNotNull {
+        it.attributes.getNamedItem("parent")?.nodeValue
+      }
+      .mapToSet {
+        AndroidResSource.StyleParentRef.of(it)
+      }
 
   private fun extractAttrsFromResourceXml(doc: Document) {
     doc.attrs().forEach {
@@ -98,15 +102,16 @@ internal class AndroidResParser(
 }
 
 internal class AndroidManifestParser(
-  private val manifests: Iterable<File>,
   private val projectDir: File,
+  private val manifests: Iterable<File>,
   private val namespace: String,
 ) {
 
   private val parser = ManifestParser(namespace)
-  val explodedManifests: List<ExplodedManifest> = compute()
 
-  private fun compute(): List<ExplodedManifest> {
+  val explodedManifests: Set<ExplodedManifest> = compute()
+
+  private fun compute(): Set<ExplodedManifest> {
     // If we have a namespace defined by the Android DSL, it is safe to parse the manifests immediately.
     if (namespace.isNotBlank()) return parseManifests()
 
@@ -131,23 +136,24 @@ internal class AndroidManifestParser(
       parseResults += remainder to malformedParser.parse(remainder)
     }
 
-    return parseResults.toExplodedManifests()
+    return parseResults.asSequence().toExplodedManifests()
   }
 
-  private fun parseManifests(): List<ExplodedManifest> = manifests
+  private fun parseManifests(): Set<ExplodedManifest> = manifests.asSequence()
     .filter { it.exists() }
     .map { it to parser.parse(it) }
     .toExplodedManifests()
 
-  private fun Iterable<Pair<File, ParseResult>>.toExplodedManifests(): List<ExplodedManifest> {
-    return map { it.toExplodedManifest() }
+  private fun Sequence<Pair<File, ParseResult>>.toExplodedManifests(): Set<ExplodedManifest> {
+    return map { it.toExplodedManifest() }.toSet()
   }
 
   private fun Pair<File, ParseResult>.toExplodedManifest(): ExplodedManifest {
     val file = first
     val parseResult = second
     val applicationName = parseResult.applicationName
     val theme = AndroidResSource.AttrRef.style(parseResult.theme)
+
     return ExplodedManifest(
       relativePath = file.toRelativeString(projectDir),
       applicationName = applicationName,

src/main/kotlin/com/autonomousapps/tasks/XmlSourceExploderTask.kt

@@ -95,17 +95,17 @@ abstract class XmlSourceExploderTask @Inject constructor(
 
       val projectDir = parameters.projectDir.get().asFile
 
-      val explodedLayouts = AndroidLayoutParser(
-        layouts = parameters.layouts.files,
-        projectDir = projectDir
-      ).explodedLayouts
       val explodedResources = AndroidResParser(
+        projectDir = projectDir,
         resources = parameters.androidRes,
-        projectDir = projectDir
       ).androidResSource
+      val explodedLayouts = AndroidLayoutParser(
+        projectDir = projectDir,
+        layouts = parameters.layouts,
+      ).explodedLayouts
       val explodedManifests = AndroidManifestParser(
-        manifests = parameters.manifests,
         projectDir = projectDir,
+        manifests = parameters.manifests,
         namespace = parameters.namespace.get(),
       ).explodedManifests
 

src/test/groovy/com/autonomousapps/internal/parse/AndroidManifestParserTest.groovy

@@ -32,7 +32,7 @@ final class AndroidManifestParserTest extends Specification {
     ]
     def projectDir = dir.resolve('project').toFile()
     def namespace = ''
-    def parser = new AndroidManifestParser(manifests, projectDir, namespace)
+    def parser = new AndroidManifestParser(projectDir, manifests, namespace)
 
     when:
     parser.explodedManifests