Module used classes by target module

main.kt

import com.google.gson.Gson
import com.google.gson.reflect.TypeToken
import java.io.File


fun main() {
    // the project needs to execute the dependency-analysis plugin in order to generate the usage json files
    val path = "PATH_TO_THE_PROJECT"
    val references = getModuleUsages(path)

    println("module classes count per target module")
    references.filter { it.variant == "demoDebug" && it.kind == "MAIN" }
        .groupBy { it.module }
        .forEach { (module, usages) ->
            usages.forEach { usage ->
                println("$module ->  ${usage.targetModule} -> ${usage.classes}")
            }
        }

    println("top 10 modules with more classes references")
    references.filter { it.variant == "demoDebug" && it.kind == "MAIN" }
        .sortedByDescending { it.classes }
        .take(10)
        .forEach {
            println("${it.module} -> ${it.targetModule} -> ${it.classes}")

        }

    println("target modules with more references")
    references.filter { it.variant == "demoDebug" && it.kind == "MAIN" }
        .groupBy { it.targetModule }
        .mapValues { it.value.size }
        .toList()
        .sortedByDescending { it.second }
        .take(10)
        .forEach { (targetModule, count) ->
            println("Module $targetModule has $count references")
        }

}


private fun getModuleUsages(path: String): List<ModuleUsages> {
    val gson = Gson()
    val moduleType = object : TypeToken<Map<String, List<ModuleDetail>>>() {}.type

    return File(path).walkTopDown()
        .filter { it.name == "usages-dependencies.json" }
        .flatMap { file ->
            val moduleDetails: Map<String, List<ModuleDetail>> = gson.fromJson(file.readText(), moduleType)
            val module = file.path.split(path)[1].split("/build")[0].replace("/", ":")

            moduleDetails.filter { it.key.contains("|") }
                .flatMap { (key, value) ->
                    val targetModule = key.split("|")[1]

                    value.mapNotNull { detail ->
                        val usedClassesCount = detail.reasons
                            .filter { it.reason?.contains(":") == true }
                            .sumBy { it.reason.split(":")[1].split(",").size }

                        if (usedClassesCount > 0) {
                            ModuleUsages(module, targetModule, detail.variant.variant, detail.variant.kind, usedClassesCount)
                        } else null
                    }
                }
        }.toList()
}


data class Variant(
    val variant: String,
    val kind: String
)

data class Reason(
    val type: String,
    val reason: String
)

data class ModuleDetail(
    val buildType: String,
    val flavor: String,
    val variant: Variant,
    val bucket: String,
    val reasons: List<Reason>
)

data class ModuleUsages(
    val module: String,
    val targetModule: String,
    val variant: String,
    val kind: String,
    val classes: Int
)