refactor: extract zip/classes dir specific code from JarExploder

for better encapsulation and less duplication

Author: patrick-dedication

src/main/kotlin/com/autonomousapps/internal/JarExploder.kt

@@ -3,17 +3,14 @@
 package com.autonomousapps.internal
 
 import com.autonomousapps.internal.asm.ClassReader
-import com.autonomousapps.internal.utils.asSequenceOfClassFiles
 import com.autonomousapps.internal.utils.getLogger
 import com.autonomousapps.model.internal.KtFile
 import com.autonomousapps.model.internal.PhysicalArtifact
-import com.autonomousapps.model.internal.PhysicalArtifact.Mode
 import com.autonomousapps.model.internal.intermediates.producer.AndroidLinterDependency
 import com.autonomousapps.model.internal.intermediates.ExplodingJar
 import com.autonomousapps.model.internal.intermediates.producer.ExplodedJar
 import com.autonomousapps.services.InMemoryCache
 import com.autonomousapps.tasks.ExplodeJarTask
-import java.util.zip.ZipFile
 
 internal class JarExploder(
   private val artifacts: List<PhysicalArtifact>,
@@ -34,15 +31,9 @@ internal class JarExploder(
 
   private fun Sequence<PhysicalArtifact>.toExplodedJars(): Set<ExplodedJar> =
     map { artifact ->
-      val explodedJar = if (artifact.isJar()) {
-        explode(artifact, Mode.ZIP)
-      } else {
-        explode(artifact, Mode.CLASSES)
-      }
-
       ExplodedJar(
         artifact = artifact,
-        exploding = explodedJar
+        exploding = explode(artifact)
       )
     }.toSortedSet()
 
@@ -54,52 +45,34 @@ internal class JarExploder(
    * jars. It seems that the behavior when requesting the "android-classes" artifact view has changed (previously we'd
    * get jars, but now we get class files).
    */
-  private fun explode(artifact: PhysicalArtifact, mode: Mode): ExplodingJar {
+  private fun explode(artifact: PhysicalArtifact): ExplodingJar {
     val entry = findInCache(artifact)
     if (entry != null) return entry
 
-    val ktFiles: Set<KtFile>
+    return artifact.withContent { content ->
 
-    val visitors = when (mode) {
-      Mode.ZIP -> {
-        ZipFile(artifact.file).use { zip ->
-          ktFiles = KtFile.fromZip(zip)
+      val ktFiles: Set<KtFile> = content.ktFiles()
 
-          zip.asSequenceOfClassFiles()
-            .map { classEntry ->
-              ClassNameAndAnnotationsVisitor(logger).apply {
-                val reader = zip.getInputStream(classEntry).use { ClassReader(it.readBytes()) }
-                reader.accept(this, 0)
-              }
-            }.toList()
+      val visitors = content.asSequenceOfClassFiles().map { classFile ->
+        ClassNameAndAnnotationsVisitor(logger).apply {
+          val reader = ClassReader(classFile.readBytes())
+          reader.accept(this, 0)
         }
       }
 
-      Mode.CLASSES -> {
-        ktFiles = KtFile.fromDirectory(artifact.file)
+      val analyzedClasses = visitors.map { it.getAnalyzedClass() }
+        .filterNot {
+          // Filter out `java` packages, but not `javax`
+          it.className.startsWith("java.")
+        }
+        .toSortedSet()
 
-        artifact.file.asSequenceOfClassFiles()
-          .map { classFile ->
-            ClassNameAndAnnotationsVisitor(logger).apply {
-              val reader = classFile.inputStream().use { ClassReader(it.readBytes()) }
-              reader.accept(this, 0)
-            }
-          }.toList()
-      }
+      ExplodingJar(
+        analyzedClasses = analyzedClasses,
+        ktFiles = ktFiles,
+        androidLintRegistry = findAndroidLinter(artifact)
+      ).also { putInCache(artifact, it) }
     }
-
-    val analyzedClasses = visitors.map { it.getAnalyzedClass() }
-      .filterNot {
-        // Filter out `java` packages, but not `javax`
-        it.className.startsWith("java.")
-      }
-      .toSortedSet()
-
-    return ExplodingJar(
-      analyzedClasses = analyzedClasses,
-      ktFiles = ktFiles,
-      androidLintRegistry = findAndroidLinter(artifact)
-    ).also { putInCache(artifact, it) }
   }
 
   private fun findInCache(artifact: PhysicalArtifact): ExplodingJar? {

src/main/kotlin/com/autonomousapps/internal/artifacts/processing/Artifact.kt

@@ -0,0 +1,13 @@
+// Copyright (c) 2025. Tony Robalik.
+// SPDX-License-Identifier: Apache-2.0
+package com.autonomousapps.internal.artifacts.processing
+
+import com.autonomousapps.model.internal.KtFile
+
+internal interface Artifact {
+  fun hasKotlinClasses(): Boolean
+
+  fun ktFiles(): Set<KtFile>
+
+  fun asSequenceOfClassFiles(): Sequence<ClassFile>
+}

src/main/kotlin/com/autonomousapps/internal/artifacts/processing/ClassFile.kt

@@ -0,0 +1,10 @@
+// Copyright (c) 2025. Tony Robalik.
+// SPDX-License-Identifier: Apache-2.0
+package com.autonomousapps.internal.artifacts.processing
+
+import java.io.InputStream
+
+internal class ClassFile(private val inputStreamSupplier: () -> InputStream, val packagePath: String) {
+
+  fun readBytes(): ByteArray = inputStreamSupplier().use { it.readBytes() }
+}

src/main/kotlin/com/autonomousapps/internal/artifacts/processing/DirectoryArtifact.kt

@@ -0,0 +1,27 @@
+// Copyright (c) 2025. Tony Robalik.
+// SPDX-License-Identifier: Apache-2.0
+package com.autonomousapps.internal.artifacts.processing
+
+import com.autonomousapps.internal.utils.Files
+import com.autonomousapps.internal.utils.asSequenceOfClassFiles
+import com.autonomousapps.model.internal.KtFile
+import java.io.File
+
+internal class DirectoryArtifact(val dir: File) : Artifact {
+
+  init {
+    check(dir.isDirectory) { "Expected directory. Was '${dir.absolutePath}'" }
+  }
+
+  override fun hasKotlinClasses(): Boolean = ktFiles().isNotEmpty()
+
+  override fun ktFiles(): Set<KtFile> = KtFile.fromDirectory(dir)
+
+  override fun asSequenceOfClassFiles(): Sequence<ClassFile> =
+    dir.asSequenceOfClassFiles().map { classFile ->
+      ClassFile(
+        inputStreamSupplier = { classFile.inputStream() },
+        packagePath = Files.asPackagePath(classFile)
+      )
+    }
+}

src/main/kotlin/com/autonomousapps/internal/artifacts/processing/ZipArtifact.kt

@@ -0,0 +1,26 @@
+// Copyright (c) 2025. Tony Robalik.
+// SPDX-License-Identifier: Apache-2.0
+package com.autonomousapps.internal.artifacts.processing
+
+import com.autonomousapps.internal.utils.asSequenceOfClassFiles
+import com.autonomousapps.model.internal.KtFile
+import java.io.Closeable
+import java.io.File
+import java.util.zip.ZipFile
+
+internal class ZipArtifact private constructor(private val zipFile: ZipFile) : Artifact, Closeable by zipFile {
+
+  constructor(file: File) : this(ZipFile(file))
+
+  override fun hasKotlinClasses(): Boolean = KtFile.hasKotlinClasses(zipFile)
+
+  override fun ktFiles(): Set<KtFile> = KtFile.fromZip(zipFile)
+
+  override fun asSequenceOfClassFiles(): Sequence<ClassFile> =
+    zipFile.asSequenceOfClassFiles().map { entry ->
+      ClassFile(
+        inputStreamSupplier = { zipFile.getInputStream(entry) },
+        packagePath = entry.name
+      )
+    }
+}

src/main/kotlin/com/autonomousapps/model/internal/KtFile.kt

@@ -29,6 +29,8 @@ internal data class KtFile(
   internal companion object {
     private const val KOTLIN_MODULE = ".kotlin_module"
 
+    fun hasKotlinClasses(zipFile: ZipFile): Boolean = zipFile.entries().toList().any { it.name.endsWith(KOTLIN_MODULE) }
+
     fun fromDirectory(dir: File): Set<KtFile> {
       check(dir.isDirectory) { "Expected directory. Was '${dir.absolutePath}'" }
 

src/main/kotlin/com/autonomousapps/model/internal/PhysicalArtifact.kt

@@ -5,6 +5,9 @@ package com.autonomousapps.model.internal
 import com.autonomousapps.PROJECT_LOGGER
 import com.autonomousapps.internal.utils.toCoordinates
 import com.autonomousapps.model.Coordinates
+import com.autonomousapps.internal.artifacts.processing.Artifact
+import com.autonomousapps.internal.artifacts.processing.DirectoryArtifact
+import com.autonomousapps.internal.artifacts.processing.ZipArtifact
 import com.squareup.moshi.JsonClass
 import org.gradle.api.artifacts.result.ResolvedArtifactResult
 import java.io.File
@@ -16,18 +19,18 @@ internal data class PhysicalArtifact(
   val file: File,
 ) : Comparable<PhysicalArtifact> {
 
-  enum class Mode {
-    ZIP,
-    CLASSES
-  }
-
   init {
     check(isJar() || containsClassFiles()) {
       "'file' must either be a jar or a directory that contains class files. Was '$file'"
     }
   }
 
-  val mode: Mode = if (isJar()) Mode.ZIP else Mode.CLASSES
+  fun <R> withContent(action: (Artifact) -> R): R =
+    if (isJar()) {
+      ZipArtifact(file).use { action(it) }
+    } else {
+      action(DirectoryArtifact(file))
+    }
 
   fun isJar(): Boolean = isJar(file)
   fun containsClassFiles(): Boolean = containsClassFiles(file)

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

@@ -8,9 +8,7 @@ import com.autonomousapps.internal.KotlinMetadataVisitor
 import com.autonomousapps.internal.asm.ClassReader
 import com.autonomousapps.internal.utils.*
 import com.autonomousapps.model.internal.InlineMemberCapability
-import com.autonomousapps.model.internal.KtFile
 import com.autonomousapps.model.internal.PhysicalArtifact
-import com.autonomousapps.model.internal.PhysicalArtifact.Mode
 import com.autonomousapps.model.internal.TypealiasCapability
 import com.autonomousapps.model.internal.intermediates.producer.InlineMemberDependency
 import com.autonomousapps.model.internal.intermediates.producer.TypealiasDependency
@@ -26,7 +24,6 @@ import org.gradle.workers.WorkAction
 import org.gradle.workers.WorkParameters
 import org.gradle.workers.WorkerExecutor
 import java.io.File
-import java.util.zip.ZipFile
 import javax.inject.Inject
 
 @CacheableTask
@@ -135,9 +132,9 @@ internal class KotlinMagicFinder(
     artifacts.asSequence()
       .filter {
         it.isJar() || it.containsClassFiles()
-      }.map { artifact ->
-        artifact to findKotlinMagic(artifact, artifact.mode)
-      }.forEach { (artifact, capabilities) ->
+      }
+      .associateWith(::findKotlinMagic)
+      .forEach { (artifact, capabilities) ->
         if (capabilities.inlineMembers.isNotEmpty()) {
           inlineMembersMut += InlineMemberDependency.newInstance(artifact.coordinates, capabilities.inlineMembers)
         }
@@ -162,10 +159,14 @@ internal class KotlinMagicFinder(
    * An import statement with either of those would import the `kotlin.jdk7.use()` inline function, contributed by the
    * "org.jetbrains.kotlin:kotlin-stdlib-jdk7" module.
    */
-  private fun findKotlinMagic(artifact: PhysicalArtifact, mode: Mode): KotlinCapabilities {
+  private fun findKotlinMagic(artifact: PhysicalArtifact): KotlinCapabilities {
     val cached = findInCache(artifact)
     if (cached != null) return cached
 
+    if (!artifact.withContent { it.hasKotlinClasses() }) {
+      return KotlinCapabilities.EMPTY
+    }
+
     fun packageName(fileLike: String): String {
       return if (fileLike.contains('/')) {
         // entry is in a package
@@ -179,75 +180,32 @@ internal class KotlinMagicFinder(
     val inlineMembers = mutableSetOf<InlineMemberCapability.InlineMember>()
     val typealiases = mutableSetOf<TypealiasCapability.Typealias>()
 
-    when (mode) {
-      Mode.ZIP -> {
-        ZipFile(artifact.file).use { zipFile ->
-          val entries = zipFile.entries().toList()
-          // Only look at jars that have actual Kotlin classes in them
-          if (entries.none { it.name.endsWith(".kotlin_module") }) {
-            return KotlinCapabilities.EMPTY
-          }
+    artifact.withContent { content ->
+      content.asSequenceOfClassFiles().mapNotNull { classFile ->
+        // TODO an entry with `META-INF/proguard/androidx-annotations.pro`
+        val kotlinMagic = readClass(
+          ClassReader(classFile.readBytes()),
+          classFile.packagePath
+        ) ?: return@mapNotNull null
 
-          entries.asSequenceOfClassFiles()
-            .mapNotNull { entry ->
-              // TODO an entry with `META-INF/proguard/androidx-annotations.pro`
-              val kotlinMagic = readClass(
-                zipFile.getInputStream(entry).use { ClassReader(it.readBytes()) },
-                entry.name
-              ) ?: return@mapNotNull null
-
-              entry to kotlinMagic
-            }
-            .forEach { (entry, kotlinMagic) ->
-              if (kotlinMagic.inlineMembers != null) {
-                inlineMembers += InlineMemberCapability.InlineMember.newInstance(
-                  packageName = packageName(entry.name),
-                  // Guaranteed to be non-empty
-                  inlineMembers = kotlinMagic.inlineMembers
-                )
-              }
-
-              if (kotlinMagic.typealiases != null) {
-                typealiases += TypealiasCapability.Typealias.newInstance(
-                  packageName = packageName(entry.name),
-                  typealiases = kotlinMagic.typealiases
-                )
-              }
-            }
-        }
+        classFile.packagePath to kotlinMagic
       }
-
-      Mode.CLASSES -> {
-        if (KtFile.fromDirectory(artifact.file).isEmpty()) {
-          return KotlinCapabilities.EMPTY
-        }
-
-        artifact.file.asSequenceOfClassFiles()
-          .mapNotNull { classFile ->
-            val kotlinMagic = readClass(
-              classFile.inputStream().use { ClassReader(it.readBytes()) },
-              Files.asPackagePath(classFile)
-            ) ?: return@mapNotNull null
-
-            classFile to kotlinMagic
+        .forEach { (packagePath, kotlinMagic) ->
+          if (kotlinMagic.inlineMembers != null) {
+            inlineMembers += InlineMemberCapability.InlineMember.newInstance(
+              packageName = packageName(packagePath),
+              // Guaranteed to be non-empty
+              inlineMembers = kotlinMagic.inlineMembers
+            )
           }
-          .forEach { (classFile, kotlinMagic) ->
-            if (kotlinMagic.inlineMembers != null) {
-              inlineMembers += InlineMemberCapability.InlineMember.newInstance(
-                packageName = packageName(Files.asPackagePath(classFile)),
-                // Guaranteed to be non-empty
-                inlineMembers = kotlinMagic.inlineMembers
-              )
-            }
-
-            if (kotlinMagic.typealiases != null) {
-              typealiases += TypealiasCapability.Typealias.newInstance(
-                packageName = packageName(Files.asPackagePath(classFile)),
-                typealiases = kotlinMagic.typealiases
-              )
-            }
+
+          if (kotlinMagic.typealiases != null) {
+            typealiases += TypealiasCapability.Typealias.newInstance(
+              packageName = packageName(packagePath),
+              typealiases = kotlinMagic.typealiases
+            )
           }
-      }
+        }
     }
 
     val kotlinCapabilities = KotlinCapabilities(inlineMembers, typealiases)