Rewrite based on code from the GitHub Dependency Graph Gradle Plugin

COPYING

@@ -1,20 +1,7 @@
-Copyright © Tad Fisher and the gradle2nix contributors
+Copyright © Tad Fisher and the gradle2nix contributors, and licensed
+under the Apache License 2.0.
 
-Permission is hereby granted, free of charge, to any person obtaining
+Based on substantial portions of the GitHub Dependency Graph Gradle Plugin,
-a copy of this software and associated documentation files (the
+Copyright © Gradle, Inc and licensed under the Apache License 2.0.
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
 
-The above copyright notice and this permission notice shall be
+See LICENSE for the full text of the Apache License 2.0.
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

LICENSE

@@ -0,0 +1,177 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS

app/build.gradle.kts

@@ -1,27 +1,28 @@
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-
 plugins {
-    kotlin("jvm")
+    id("org.jetbrains.kotlin.jvm")
-    kotlin("kapt")
+    id("org.jetbrains.kotlin.plugin.serialization")
     application
 }
 
+configurations {
+    register("share")
+}
+
 dependencies {
-    implementation(project(":model"))
     implementation(kotlin("reflect"))
-    implementation("org.gradle:gradle-tooling-api:${gradle.gradleVersion}")
+    implementation(project(":model"))
-    implementation("com.github.ajalt:clikt:latest.release")
+    implementation(libs.clikt)
-    implementation("org.slf4j:slf4j-api:latest.release")
+    implementation(libs.gradle.toolingApi)
-    runtimeOnly("org.slf4j:slf4j-simple:latest.release")
+    implementation(libs.serialization.json)
-    implementation("com.squareup.moshi:moshi-adapters:latest.release")
+    implementation(libs.slf4j.api)
-    implementation("com.squareup.moshi:moshi-kotlin:latest.release")
+    runtimeOnly(libs.slf4j.simple)
-    kapt("com.squareup.moshi:moshi-kotlin-codegen:latest.release")
+    implementation(libs.okio)
-    implementation("com.squareup.okio:okio:latest.release")
+
+    "share"(project(":plugin", configuration = "shadow"))
 
     testRuntimeOnly(kotlin("reflect"))
-    testImplementation("org.spekframework.spek2:spek-dsl-jvm:latest.release")
+    testImplementation(libs.kotest.assertions)
-    testRuntimeOnly("org.spekframework.spek2:spek-runner-junit5:latest.release")
+    testImplementation(libs.kotest.runner)
-    testImplementation("io.strikt:strikt-core:latest.release")
 }
 
 application {
@@ -29,11 +30,15 @@ application {
     applicationName = "gradle2nix"
     applicationDefaultJvmArgs += "-Dorg.nixos.gradle2nix.share=@APP_HOME@/share"
     applicationDistribution
-        .from(tasks.getByPath(":plugin:shadowJar"), "$rootDir/gradle-env.nix")
+        .from(configurations.named("share"))
         .into("share")
         .rename("plugin.*\\.jar", "plugin.jar")
 }
 
+kotlin {
+    jvmToolchain(11)
+}
+
 sourceSets {
     test {
         resources {
@@ -42,6 +47,8 @@ sourceSets {
     }
 }
 
+val updateGolden = providers.gradleProperty("update-golden")
+
 tasks {
     (run) {
         dependsOn(installDist)
@@ -52,28 +59,32 @@ tasks {
 
     startScripts {
         doLast {
-            unixScript.writeText(unixScript.readText().replace("@APP_HOME@", "\$APP_HOME"))
+            unixScript.writeText(
+                unixScript.readText()
+                    .replace("@APP_HOME@", "\\\"\$APP_HOME\\\"")
+                    .replace(Regex("DEFAULT_JVM_OPTS=\'(.*)\'")) { match ->
+                        "DEFAULT_JVM_OPTS=${match.groupValues[1]}"
+                    }
+            )
             windowsScript.writeText(windowsScript.readText().replace("@APP_HOME@", "%APP_HOME%"))
         }
     }
 
-    test {
+    withType<Test> {
+        notCompatibleWithConfigurationCache("huh?")
         dependsOn(installDist)
         doFirst {
-            systemProperties("org.nixos.gradle2nix.share" to installDist.get().destinationDir.resolve("share"))
+            if (updateGolden.isPresent) {
+                systemProperty("org.nixos.gradle2nix.update-golden", "")
             }
-        useJUnitPlatform {
+            systemProperties(
-            includeEngines("spek2")
+                "org.nixos.gradle2nix.share" to installDist.get().destinationDir.resolve("share"),
+                "org.nixos.gradle2nix.m2" to rootDir.resolve("fixtures/repositories/m2").toURI().toString()
+            )
         }
+        useJUnitPlatform()
         testLogging {
             events("passed", "skipped", "failed")
         }
     }
-
-    withType<KotlinCompile> {
-        kotlinOptions {
-            jvmTarget = "1.8"
-            freeCompilerArgs = listOf("-Xopt-in=kotlin.RequiresOptIn")
-        }
-    }
 }

app/gradle.lockfile

@@ -1,38 +0,0 @@
-# This is a Gradle generated file for dependency locking.
-# Manual edits can break the build and are not advised.
-# This file is expected to be part of source control.
-com.christophsturm:filepeek:0.1.2=testRuntimeClasspath
-com.github.ajalt:clikt:2.8.0=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
-com.squareup.moshi:moshi-adapters:1.11.0=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
-com.squareup.moshi:moshi-kotlin:1.11.0=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
-com.squareup.moshi:moshi:1.11.0=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
-com.squareup.okio:okio:3.0.0-alpha.1=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
-io.github.classgraph:classgraph:4.8.37=testRuntimeClasspath
-io.strikt:strikt-core:0.28.2=testCompileClasspath,testRuntimeClasspath
-net.swiftzer.semver:semver:1.1.1=runtimeClasspath,testRuntimeClasspath
-org.apiguardian:apiguardian-api:1.1.0=testRuntimeClasspath
-org.gradle:gradle-tooling-api:6.8.1=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
-org.jetbrains.kotlin:kotlin-reflect:1.4.20=compileClasspath,runtimeClasspath,testCompileClasspath
-org.jetbrains.kotlin:kotlin-reflect:1.4.21-2=testRuntimeClasspath
-org.jetbrains.kotlin:kotlin-stdlib-common:1.4.20=compileClasspath,runtimeClasspath
-org.jetbrains.kotlin:kotlin-stdlib-common:1.4.21-2=testCompileClasspath,testRuntimeClasspath
-org.jetbrains.kotlin:kotlin-stdlib-jdk7:1.4.20=compileClasspath,runtimeClasspath
-org.jetbrains.kotlin:kotlin-stdlib-jdk7:1.4.21-2=testCompileClasspath,testRuntimeClasspath
-org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.4.20=compileClasspath,runtimeClasspath
-org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.4.21-2=testCompileClasspath,testRuntimeClasspath
-org.jetbrains.kotlin:kotlin-stdlib:1.4.20=compileClasspath,runtimeClasspath
-org.jetbrains.kotlin:kotlin-stdlib:1.4.21-2=testCompileClasspath,testRuntimeClasspath
-org.jetbrains.kotlinx:kotlinx-coroutines-core-common:1.3.3=testRuntimeClasspath
-org.jetbrains.kotlinx:kotlinx-coroutines-core-jvm:1.4.2=testRuntimeClasspath
-org.jetbrains.kotlinx:kotlinx-coroutines-core:1.4.2=testRuntimeClasspath
-org.jetbrains:annotations:13.0=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
-org.junit.platform:junit-platform-commons:1.6.0=testRuntimeClasspath
-org.junit.platform:junit-platform-engine:1.6.0=testRuntimeClasspath
-org.junit:junit-bom:5.6.0=testRuntimeClasspath
-org.opentest4j:opentest4j:1.2.0=testCompileClasspath,testRuntimeClasspath
-org.slf4j:slf4j-api:2.0.0-alpha1=compileClasspath,runtimeClasspath,testCompileClasspath,testRuntimeClasspath
-org.slf4j:slf4j-simple:2.0.0-alpha1=runtimeClasspath,testRuntimeClasspath
-org.spekframework.spek2:spek-dsl-jvm:2.0.15=testCompileClasspath,testRuntimeClasspath
-org.spekframework.spek2:spek-runner-junit5:2.0.15=testRuntimeClasspath
-org.spekframework.spek2:spek-runtime-jvm:2.0.15=testRuntimeClasspath
-empty=

app/src/main/kotlin/org/nixos/gradle2nix/Artifact.kt

@@ -0,0 +1,9 @@
+package org.nixos.gradle2nix
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class Artifact(
+    val urls: List<String>,
+    val hash: String,
+)

app/src/main/kotlin/org/nixos/gradle2nix/Env.kt

@@ -1,50 +0,0 @@
-package org.nixos.gradle2nix
-
-import com.squareup.moshi.JsonClass
-
-@JsonClass(generateAdapter = true)
-data class NixGradleEnv(
-    val name: String,
-    val version: String,
-    val path: String,
-    val gradle: DefaultGradle,
-    val dependencies: Map<String, List<DefaultArtifact>>
-)
-
-fun buildEnv(builds: Map<String, DefaultBuild>): Map<String, NixGradleEnv> =
-    builds.mapValues { (path, build) ->
-        NixGradleEnv(
-            name = build.rootProject.name,
-            version = build.rootProject.version,
-            path = path,
-            gradle = build.gradle,
-            dependencies = mapOf(
-                "settings" to build.settingsDependencies,
-                "plugin" to build.pluginDependencies,
-                "buildscript" to build.rootProject.collectDependencies(DefaultProject::buildscriptDependencies),
-                "project" to build.rootProject.collectDependencies(DefaultProject::projectDependencies)
-            )
-        )
-    }
-
-private fun DefaultProject.collectDependencies(
-    chooser: DefaultProject.() -> List<DefaultArtifact>
-): List<DefaultArtifact> {
-    val result = mutableMapOf<ArtifactIdentifier, DefaultArtifact>()
-    mergeRepo(result, chooser())
-    for (child in children) {
-        mergeRepo(result, child.collectDependencies(chooser))
-    }
-    return result.values.toList()
-}
-
-private fun mergeRepo(
-    base: MutableMap<ArtifactIdentifier, DefaultArtifact>,
-    extra: List<DefaultArtifact>
-) {
-    extra.forEach { artifact ->
-        base.merge(artifact.id, artifact) { old, new ->
-            old.copy(urls = old.urls.union(new.urls).toList())
-        }
-    }
-}

app/src/main/kotlin/org/nixos/gradle2nix/GradleRunner.kt

@@ -13,19 +13,31 @@ fun connect(config: Config): ProjectConnection =
         .forProjectDirectory(config.projectDir)
         .connect()
 
-@Suppress("UnstableApiUsage")
+fun ProjectConnection.build(
-fun ProjectConnection.getBuildModel(config: Config, path: String): DefaultBuild {
+    config: Config,
-    return model(Build::class.java).apply {
+) {
+    newBuild()
+        .apply {
+            if (config.tasks.isNotEmpty()) {
+                forTasks(*config.tasks.toTypedArray())
+            } else {
+                forTasks(RESOLVE_ALL_TASK)
+            }
+            addArguments(config.gradleArgs)
             addArguments(
-            "--init-script=$shareDir/init.gradle",
+                "--init-script=${config.appHome}/init.gradle",
-            "-Porg.nixos.gradle2nix.configurations=${config.configurations.joinToString(",")}",
+                "--write-verification-metadata", "sha256"
-            "-Porg.nixos.gradle2nix.subprojects=${config.subprojects.joinToString(",")}"
             )
-        if (config.gradleArgs != null) addArguments(config.gradleArgs)
+            if (config.projectFilter != null) {
-        if (path.isNotEmpty()) addArguments("--project-dir=$path")
+                addArguments("-D${PARAM_INCLUDE_PROJECTS}")
-        if (!config.quiet) {
+            }
+            if (config.configurationFilter != null) {
+                addArguments("-D${PARAM_INCLUDE_CONFIGURATIONS}")
+            }
+            if (config.logger.verbose) {
                 setStandardOutput(System.err)
                 setStandardError(System.err)
             }
-    }.get().let { DefaultBuild(it) }
+        }
+        .run()
 }

app/src/main/kotlin/org/nixos/gradle2nix/Logger.kt

@@ -1,6 +1,7 @@
 package org.nixos.gradle2nix
 
 import java.io.PrintStream
+import kotlin.system.exitProcess
 
 class Logger(
     val out: PrintStream = System.err,
@@ -9,9 +10,9 @@ class Logger(
 
     val log: (String) -> Unit = { if (verbose) out.println(it) }
     val warn: (String) -> Unit = { out.println("Warning: $it")}
-    val error: (String) -> Unit = {
+    val error: (String) -> Nothing = {
         out.println("Error: $it")
-        System.exit(1)
+        exitProcess(1)
     }
 
     operator fun component1() = log

app/src/main/kotlin/org/nixos/gradle2nix/Main.kt

@@ -1,102 +1,97 @@
 package org.nixos.gradle2nix
 
-import com.github.ajalt.clikt.completion.CompletionCandidates
 import com.github.ajalt.clikt.core.CliktCommand
 import com.github.ajalt.clikt.core.context
 import com.github.ajalt.clikt.output.CliktHelpFormatter
-import com.github.ajalt.clikt.parameters.arguments.ProcessedArgument
 import com.github.ajalt.clikt.parameters.arguments.argument
-import com.github.ajalt.clikt.parameters.arguments.convert
+import com.github.ajalt.clikt.parameters.arguments.multiple
-import com.github.ajalt.clikt.parameters.arguments.default
 import com.github.ajalt.clikt.parameters.options.default
 import com.github.ajalt.clikt.parameters.options.flag
 import com.github.ajalt.clikt.parameters.options.multiple
 import com.github.ajalt.clikt.parameters.options.option
 import com.github.ajalt.clikt.parameters.options.validate
 import com.github.ajalt.clikt.parameters.types.file
-import com.squareup.moshi.Moshi
-import com.squareup.moshi.Types
-import okio.buffer
-import okio.sink
 import java.io.File
-
+import kotlinx.serialization.ExperimentalSerializationApi
-val shareDir: String = System.getProperty("org.nixos.gradle2nix.share")
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.encodeToStream
 
 data class Config(
+    val appHome: File,
+    val gradleHome: File,
     val gradleVersion: String?,
-    val gradleArgs: String?,
+    val gradleArgs: List<String>,
-    val configurations: List<String>,
+    val projectFilter: String?,
+    val configurationFilter: String?,
     val projectDir: File,
-    val includes: List<File>,
+    val tasks: List<String>,
-    val subprojects: List<String>,
+    val logger: Logger,
-    val buildSrc: Boolean,
+)
-    val quiet: Boolean
+
-) {
+@OptIn(ExperimentalSerializationApi::class)
-    val allProjects = listOf(projectDir) + includes
+private val JsonFormat = Json {
+    prettyPrint = true
+    prettyPrintIndent = "  "
 }
 
-class Main : CliktCommand(
+class Gradle2Nix : CliktCommand(
     name = "gradle2nix"
 ) {
-    private val gradleVersion: String? by option("--gradle-version", "-g",
+    private val gradleVersion: String? by option(
+        "--gradle-version", "-g",
         metavar = "VERSION",
-        help = "Use a specific Gradle version")
+        help = "Use a specific Gradle version"
+    )
 
-    private val gradleArgs: String? by option("--gradle-args", "-a",
+    private val projectFilter: String? by option(
-        metavar = "ARGS",
+        "--projects", "-p",
-        help = "Extra arguments to pass to Gradle")
+        metavar = "REGEX",
+        help = "Regex to filter Gradle projects (default: include all projects)"
+    )
 
-    private val configurations: List<String> by option("--configuration", "-c",
+    private val configurationFilter: String? by option(
-        metavar = "NAME",
+        "--configurations", "-c",
-        help = "Add a configuration to resolve (default: all configurations)")
+        metavar = "REGEX",
-        .multiple()
+        help = "Regex to filter Gradle configurations (default: include all configurations)")
 
-    private val includes: List<File> by option("--include", "-i",
+    val outDir: File? by option(
-        metavar = "DIR",
+        "--out-dir", "-o",
-        help = "Add an additional project to include")
-        .file(mustExist = true, canBeFile = false, canBeDir = true, mustBeReadable = true)
-        .multiple()
-        .validate { files ->
-            val failures = files.filterNot { it.isProjectRoot() }
-            if (failures.isNotEmpty()) {
-                val message = failures.joinToString("\n    ")
-                fail("Included builds are not Gradle projects:\n$message\n" +
-                        "Gradle projects must contain a settings.gradle or settings.gradle.kts script.")
-            }
-        }
-
-    private val subprojects: List<String> by option("--project", "-p",
-        metavar = "PATH",
-        help = "Only resolve these subproject paths, e.g. ':', or ':sub:project' (default: all projects)")
-        .multiple()
-        .validate { paths ->
-            val failures = paths.filterNot { it.startsWith(":") }
-            if (failures.isNotEmpty()) {
-                val message = failures.joinToString("\n    ")
-                fail("Subproject paths must be absolute:\n$message\n" +
-                    "Paths are in the form ':parent:child'.")
-            }
-        }
-
-    val outDir: File? by option("--out-dir", "-o",
         metavar = "DIR",
         help = "Path to write generated files (default: PROJECT-DIR)")
         .file(canBeFile = false, canBeDir = true)
 
-    val envFile: String by option("--env", "-e",
+    val envFile: String by option(
+        "--env", "-e",
         metavar = "FILENAME",
         help = "Prefix for environment files (.json and .nix)")
         .default("gradle-env")
 
-    private val buildSrc: Boolean by option("--build-src", "-b", help = "Include buildSrc project (default: true)")
-        .flag("--no-build-src", "-nb", default = true)
-
     private val quiet: Boolean by option("--quiet", "-q", help = "Disable logging")
         .flag(default = false)
 
-    private val projectDir: File by argument("PROJECT-DIR", help = "Path to the project root (default: .)")
+    private val projectDir: File by option(
-        .projectDir()
+        "--projectDir", "-d",
-        .default(File("."))
+        metavar = "PROJECT-DIR",
+        help = "Path to the project root (default: .)")
+        .file()
+        .default(File("."), "Current directory")
+        .validate { file ->
+            if (!file.exists()) fail("Directory \"$file\" does not exist.")
+            if (file.isFile) fail("Directory \"$file\" is a file.")
+            if (!file.canRead()) fail("Directory \"$file\" is not readable.")
+            if (!file.isProjectRoot()) fail("Directory \"$file\" is not a Gradle project.")
+        }
+
+    private val tasks: List<String> by option(
+        "--tasks", "-t",
+        metavar = "TASKS",
+        help = "Gradle tasks to run"
+    ).multiple()
+
+    private val gradleArgs: List<String> by argument(
+        name = "ARGS",
+        help = "Extra arguments to pass to Gradle"
+    ).multiple()
 
     init {
         context {
@@ -107,65 +102,59 @@ class Main : CliktCommand(
     // Visible for testing
     lateinit var config: Config
 
+    @OptIn(ExperimentalSerializationApi::class)
     override fun run() {
+        val appHome = System.getProperty("org.nixos.gradle2nix.share")
+        if (appHome == null) {
+            System.err.println("Error: could not locate the /share directory in the gradle2nix installation")
+        }
+        val gradleHome = System.getenv("GRADLE_USER_HOME")?.let(::File) ?: File("${System.getProperty("user.home")}/.gradle")
+        val logger = Logger(verbose = !quiet)
+
         config = Config(
+            File(appHome),
+            gradleHome,
             gradleVersion,
             gradleArgs,
-            configurations,
+            projectFilter,
+            configurationFilter,
             projectDir,
-            includes,
+            tasks,
-            subprojects,
+            logger
-            buildSrc,
-            quiet
         )
-        val (log, _, _) = Logger(verbose = !config.quiet)
 
-        val paths = resolveProjects(config).map { p ->
+        val (log, _, error) = logger
-            p.toRelativeString(config.projectDir)
-        }
 
-        val models = connect(config).use { connection ->
+        val metadata = File("$projectDir/gradle/verification-metadata.xml")
-            paths.associateWith { project ->
+        if (metadata.exists()) {
-                log("Resolving project model: ${project.takeIf { it.isNotEmpty() } ?: "root project"}...")
+            val backup = metadata.resolveSibling("verification-metadata.xml.bak")
-                connection.getBuildModel(config, project)
+            if (metadata.renameTo(backup)) {
+                Runtime.getRuntime().addShutdownHook(Thread {
+                    metadata.delete()
+                    backup.renameTo(metadata)
+                })
             }
         }
 
-        log("Building environment...")
+        connect(config).use { connection ->
-        val nixGradleEnv = buildEnv(models)
+            connection.build(config)
+        }
+
+        val dependencies = try {
+            processDependencies(config)
+        } catch (e: Throwable) {
+            error("Dependency parsing failed: ${e.message}")
+        }
 
         val outDir = outDir ?: projectDir
-
         val json = outDir.resolve("$envFile.json")
         log("Writing environment to $json")
-
+        json.outputStream().buffered().use { output ->
-        json.sink().buffer().use { out ->
+            JsonFormat.encodeToStream(dependencies, output)
-            Moshi.Builder().build()
-                .adapter<Map<String, NixGradleEnv>>(
-                    Types.newParameterizedType(Map::class.java, String::class.java, NixGradleEnv::class.java)
-                )
-                .indent("  ")
-                .toJson(out, nixGradleEnv)
-            out.flush()
-        }
-
-        val nix = outDir.resolve("$envFile.nix")
-        log("Writing Nix script to $nix")
-
-        File(shareDir).resolve("gradle-env.nix").copyTo(nix, overwrite = true)
-    }
-}
-
-fun ProcessedArgument<String, String>.projectDir(): ProcessedArgument<File, File> {
-    return convert(completionCandidates = CompletionCandidates.Path) {
-        File(it).also { file ->
-            if (!file.exists()) fail("Directory \"$file\" does not exist.")
-            if (file.isFile) fail("Directory \"$file\" is a file.")
-            if (!file.canRead()) fail("Directory \"$file\" is not readable.")
-            if (!file.isProjectRoot()) fail("Directory \"$file\" is not a Gradle project.")
         }
     }
 }
 
-fun main(args: Array<String>) = Main().main(args)
+fun main(args: Array<String>) {
-
+    Gradle2Nix().main(args)
+}

app/src/main/kotlin/org/nixos/gradle2nix/Process.kt

@@ -0,0 +1,207 @@
+package org.nixos.gradle2nix
+
+import java.io.File
+import kotlinx.serialization.ExperimentalSerializationApi
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.decodeFromStream
+import okio.ByteString.Companion.decodeHex
+import okio.HashingSource
+import okio.blackholeSink
+import okio.buffer
+import okio.source
+import org.nixos.gradle2nix.dependency.ModuleComponentIdentifier
+import org.nixos.gradle2nix.dependencygraph.model.DependencyCoordinates
+import org.nixos.gradle2nix.dependencygraph.model.Repository
+import org.nixos.gradle2nix.dependencygraph.model.ResolvedConfiguration
+import org.nixos.gradle2nix.metadata.ArtifactVerificationMetadata
+import org.nixos.gradle2nix.metadata.Checksum
+import org.nixos.gradle2nix.metadata.ChecksumKind
+import org.nixos.gradle2nix.metadata.ComponentVerificationMetadata
+import org.nixos.gradle2nix.metadata.DependencyVerificationsXmlReader
+import org.nixos.gradle2nix.metadata.DependencyVerifier
+
+// Local Maven repository for testing
+private val m2 = System.getProperty("org.nixos.gradle2nix.m2")
+
+private fun shouldSkipRepository(repository: Repository): Boolean {
+    return repository.artifactResources.all { it.startsWith("file:") && (m2 == null || !it.startsWith(m2)) } ||
+            repository.metadataResources.all { it.startsWith("file:") && (m2 == null || !it.startsWith(m2)) }
+}
+
+fun processDependencies(config: Config): Map<String, Map<String, Artifact>> {
+    val verifier = readVerificationMetadata(config)
+    val configurations = readDependencyGraph(config)
+
+    val repositories = configurations
+        .flatMap { it.repositories }
+        .associateBy { it.id }
+        .filterNot { (id, repo) ->
+            if (shouldSkipRepository(repo)) {
+                config.logger.warn("$id: all URLs are files; skipping")
+                true
+            } else {
+                false
+            }
+        }
+    if (repositories.isEmpty()) {
+        config.logger.warn("no repositories found in any configuration")
+        return emptyMap()
+    }
+
+    return configurations.asSequence()
+        .flatMap { it.allDependencies.asSequence() }
+        .groupBy { it.id }
+        .mapNotNull { (id, dependencies) ->
+            val deps = dependencies.toSet()
+            if (deps.isEmpty()) {
+                config.logger.warn("$id: no resolved dependencies in dependency graph")
+                return@mapNotNull null
+            }
+            val coordinates = deps.first().coordinates
+            val componentId = ModuleComponentIdentifier(
+                coordinates.group,
+                coordinates.module,
+                coordinates.version
+            )
+            val metadata = verifier.verificationMetadata[componentId]
+                ?: verifyComponentFilesInCache(config, componentId)
+            if (metadata == null) {
+                config.logger.warn("$id: not present in metadata or cache; skipping")
+                return@mapNotNull null
+            }
+
+            val repoIds = dependencies.mapNotNull { it.repository }
+            if (repoIds.isEmpty()) {
+                config.logger.warn("$id: no repository ids in dependency graph; skipping")
+                return@mapNotNull null
+            }
+            val repos = repoIds.mapNotNull(repositories::get)
+            if (repos.isEmpty()) {
+                config.logger.warn("$id: no repositories found for repository ids $repoIds; skipping")
+                return@mapNotNull null
+            }
+
+            id to metadata.artifactVerifications.associate { meta ->
+                meta.artifactName to Artifact(
+                    urls = repos
+                        .flatMap { repository -> artifactUrls(coordinates, meta, repository) }
+                        .distinct(),
+                    hash = meta.checksums.maxBy { c -> c.kind.ordinal }.toSri()
+                )
+            }
+        }
+        .toMap()
+}
+
+private fun readVerificationMetadata(config: Config): DependencyVerifier {
+    return config.projectDir.resolve("gradle/verification-metadata.xml")
+        .inputStream()
+        .buffered()
+        .use { input -> DependencyVerificationsXmlReader.readFromXml(input) }
+}
+
+@OptIn(ExperimentalSerializationApi::class)
+private fun readDependencyGraph(config: Config): List<ResolvedConfiguration> {
+    return config.projectDir.resolve("build/reports/nix-dependency-graph/dependency-graph.json")
+        .inputStream()
+        .buffered()
+        .use { input -> Json.decodeFromStream(input) }
+}
+
+private fun verifyComponentFilesInCache(
+    config: Config,
+    component: ModuleComponentIdentifier
+): ComponentVerificationMetadata? {
+    val cacheDir = config.gradleHome.resolve("caches/modules-2/files-2.1/${component.group}/${component.module}/${component.version}")
+    if (!cacheDir.exists()) {
+        return null
+    }
+    val verifications = cacheDir.walkBottomUp().filter { it.isFile }.map { f ->
+        ArtifactVerificationMetadata(
+            f.name,
+            listOf(Checksum(ChecksumKind.sha256, f.sha256()))
+        )
+    }
+    config.logger.log("$component: obtained artifact hashes from Gradle cache.")
+    return ComponentVerificationMetadata(component, verifications.toList())
+}
+
+private fun File.sha256(): String {
+    val source = HashingSource.sha256(source())
+    source.buffer().readAll(blackholeSink())
+    return source.hash.hex()
+}
+
+private fun Checksum.toSri(): String {
+    val hash = value.decodeHex().base64()
+    return when (kind) {
+        ChecksumKind.md5 -> "md5-$hash"
+        ChecksumKind.sha1 -> "sha1-$hash"
+        ChecksumKind.sha256 -> "sha256-$hash"
+        ChecksumKind.sha512 -> "sha512-$hash"
+    }
+}
+
+private fun artifactUrls(
+    coordinates: DependencyCoordinates,
+    metadata: ArtifactVerificationMetadata,
+    repository: Repository
+): List<String> {
+    val groupAsPath = coordinates.group.replace(".", "/")
+
+    val attributes = mutableMapOf(
+        "organisation" to if (repository.m2Compatible) groupAsPath else coordinates.group,
+        "module" to coordinates.module,
+        "revision" to coordinates.version,
+    ) + fileAttributes(metadata.artifactName, coordinates.version)
+
+    val resources = when (attributes["ext"]) {
+        "pom" -> if ("mavenPom" in repository.metadataSources) repository.metadataResources else repository.artifactResources
+        "xml" -> if ("ivyDescriptor" in repository.metadataSources) repository.metadataResources else repository.artifactResources
+        "module" -> if ("gradleMetadata" in repository.metadataSources || "ignoreGradleMetadataRedirection" !in repository.metadataSources) {
+            repository.metadataResources
+        } else {
+            repository.artifactResources
+        }
+        else -> repository.artifactResources
+    }
+
+    val urls = mutableListOf<String>()
+
+    for (resource in resources) {
+        val location = attributes.entries.fold(fill(resource, attributes)) { acc, (key, value) ->
+            acc.replace("[$key]", value)
+        }
+        if (location.none { it == '[' || it == ']' }) {
+            urls.add(location)
+        }
+    }
+
+    return urls
+}
+
+private val optionalRegex = Regex("\\(([^)]+)\\)")
+private val attrRegex = Regex("\\[([^]]+)]")
+
+private fun fill(template: String, attributes: Map<String, String>): String {
+    return optionalRegex.replace(template) { match ->
+        attrRegex.find(match.value)?.groupValues?.get(1)?.let { attr ->
+            attributes[attr]?.takeIf { it.isNotBlank() }?.let { value ->
+                match.groupValues[1].replace("[$attr]", value)
+            }
+        } ?: ""
+    }
+}
+
+// Gradle persists artifacts with the Maven artifact pattern, which may not match the repository's pattern.
+private fun fileAttributes(file: String, version: String): Map<String, String> {
+    val parts = Regex("(.+)-$version(-([^.]+))?(\\.(.+))?").matchEntire(file) ?: return emptyMap()
+
+    val (artifact, _, classifier, _, ext) = parts.destructured
+
+    return buildMap {
+        put("artifact", artifact)
+        put("classifier", classifier)
+        put("ext", ext)
+    }
+}

app/src/main/kotlin/org/nixos/gradle2nix/Projects.kt

@@ -2,16 +2,5 @@ package org.nixos.gradle2nix
 
 import java.io.File
 
-fun resolveProjects(config: Config) = config.allProjects.run {
-    if (config.buildSrc) {
-        flatMap { listOfNotNull(it, it.findBuildSrc()) }
-    } else {
-        this
-    }
-}
-
-fun File.findBuildSrc(): File? =
-    resolve("buildSrc").takeIf { it.isDirectory }
-
 fun File.isProjectRoot(): Boolean =
     isDirectory && (resolve("settings.gradle").isFile || resolve("settings.gradle.kts").isFile)

app/src/main/kotlin/org/nixos/gradle2nix/dependency/ComponentArtifactIdentifier.kt

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2014 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.nixos.gradle2nix.dependency
+
+/**
+ * An opaque immutable identifier for an artifact that belongs to some component instance.
+ */
+interface ComponentArtifactIdentifier {
+    /**
+     * Returns the id of the component that this artifact belongs to.
+     */
+    val componentIdentifier: ComponentIdentifier
+
+    /**
+     * Returns some human-consumable display name for this artifact.
+     */
+    val displayName: String
+}

app/src/main/kotlin/org/nixos/gradle2nix/dependency/ComponentIdentifier.kt

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.nixos.gradle2nix.dependency
+
+/**
+ * An opaque immutable identifier for a component instance. There are various sub-interfaces that expose specific details about the identifier.
+ */
+interface ComponentIdentifier {
+    /**
+     * Returns a human-consumable display name for this identifier.
+     *
+     * @return Component identifier display name
+     */
+    val displayName: String
+}

app/src/main/kotlin/org/nixos/gradle2nix/dependency/ModuleComponentArtifactIdentifier.kt

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.nixos.gradle2nix.dependency
+
+/**
+ * An immutable identifier for an artifact that belongs to some module version.
+ */
+interface ModuleComponentArtifactIdentifier : ComponentArtifactIdentifier {
+    /**
+     * Returns the id of the component that this artifact belongs to.
+     */
+    override val componentIdentifier: ModuleComponentIdentifier
+
+    /**
+     * Returns a file base name that can be used for this artifact.
+     */
+    val fileName: String
+}
+
+data class DefaultModuleComponentArtifactIdentifier(
+    override val componentIdentifier: ModuleComponentIdentifier,
+    override val fileName: String,
+) : ModuleComponentArtifactIdentifier {
+    override val displayName: String get() = "$fileName ($componentIdentifier)"
+
+    override fun toString(): String = displayName
+}

app/src/main/kotlin/org/nixos/gradle2nix/dependency/ModuleComponentIdentifier.kt

@@ -0,0 +1,76 @@
+/*
+ * Copyright 2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.nixos.gradle2nix.dependency
+
+/**
+ * An identifier for a component instance which is available as a module version.
+  */
+interface ModuleComponentIdentifier : ComponentIdentifier {
+    /**
+     * The module group of the component.
+     *
+     * @return Component group
+     */
+    val group: String
+
+    /**
+     * The module name of the component.
+     *
+     * @return Component module
+     */
+    val module: String
+
+    /**
+     * The module version of the component.
+     *
+     * @return Component version
+     */
+    val version: String
+
+    /**
+     * The module identifier of the component. Returns the same information
+     * as [group] and [module].
+     *
+     * @return the module identifier
+     */
+    val moduleIdentifier: ModuleIdentifier
+}
+
+data class DefaultModuleComponentIdentifier(
+    override val moduleIdentifier: ModuleIdentifier,
+    override val version: String,
+) : ModuleComponentIdentifier {
+    override val group: String
+        get() = moduleIdentifier.group
+
+    override val module: String
+        get() = moduleIdentifier.name
+
+    override val displayName: String
+        get() = "$group:$module:$version"
+
+    override fun toString(): String = displayName
+}
+
+
+fun ModuleComponentIdentifier(
+    group: String,
+    module: String,
+    version: String
+): ModuleComponentIdentifier = DefaultModuleComponentIdentifier(
+    DefaultModuleIdentifier(group, module),
+    version
+)

app/src/main/kotlin/org/nixos/gradle2nix/dependency/ModuleIdentifier.kt

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2012 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.nixos.gradle2nix.dependency
+
+/**
+ * The identifier of a module.
+ */
+interface ModuleIdentifier {
+    /**
+     * The group of the module.
+     *
+     * @return module group
+     */
+    val group: String
+
+    /**
+     * The name of the module.
+     *
+     * @return module name
+     */
+    val name: String
+}
+
+data class DefaultModuleIdentifier(
+    override val group: String,
+    override val name: String,
+) : ModuleIdentifier

app/src/main/kotlin/org/nixos/gradle2nix/metadata/ArtifactVerificationMetadata.kt

@@ -0,0 +1,6 @@
+package org.nixos.gradle2nix.metadata
+
+data class ArtifactVerificationMetadata(
+    val artifactName: String,
+    val checksums: List<Checksum>
+)

app/src/main/kotlin/org/nixos/gradle2nix/metadata/Checksum.kt

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.nixos.gradle2nix.metadata
+
+/**
+ * Internal representation of a checksum, aimed at *verification*.
+ * A checksum consists of a kind (md5, sha1, ...), a value, but also
+ * provides *alternatives*. Alternatives are checksums which are
+ * deemed trusted, because sometimes in a single build we can see different
+ * checksums for the same module, because they are sourced from different
+ * repositories.
+ *
+ * In theory, this shouldn't be allowed. However, it's often the case that
+ * an artifact, in particular _metadata artifacts_ (POM files, ...) differ
+ * from one repository to the other (either by end of lines, additional line
+ * at the end of the file, ...). Because they are different doesn't mean that
+ * they are compromised, so this is a facility for the user to declare "I know
+ * I should use a single source of truth but the infrastructure is hard or
+ * impossible to fix so let's trust this source".
+ *
+ * In addition to the list of alternatives, a checksum also provides a source,
+ * which is documentation to explain where a checksum was found.
+ */
+data class Checksum(
+    val kind: ChecksumKind,
+    val value: String,
+    val alternatives: Set<String> = emptySet(),
+    val origin: String? = null,
+    val reason: String? = null
+)

app/src/main/kotlin/org/nixos/gradle2nix/metadata/ChecksumKind.kt

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.nixos.gradle2nix.metadata
+
+enum class ChecksumKind(val algorithm: String) {
+    md5("MD5"),
+    sha1("SHA1"),
+    sha256("SHA-256"),
+    sha512("SHA-512");
+
+    companion object {
+        private val SORTED_BY_SECURITY: List<ChecksumKind> = listOf(sha512, sha256, sha1, md5)
+        fun mostSecureFirst(): List<ChecksumKind> {
+            return SORTED_BY_SECURITY
+        }
+    }
+}

app/src/main/kotlin/org/nixos/gradle2nix/metadata/ComponentVerificationMetadata.kt

@@ -0,0 +1,8 @@
+package org.nixos.gradle2nix.metadata
+
+import org.nixos.gradle2nix.dependency.ModuleComponentIdentifier
+
+data class ComponentVerificationMetadata(
+    val componentId: ModuleComponentIdentifier,
+    val artifactVerifications: List<ArtifactVerificationMetadata>,
+)

app/src/main/kotlin/org/nixos/gradle2nix/metadata/DependencyVerificationConfiguration.kt

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.nixos.gradle2nix.metadata
+
+import org.nixos.gradle2nix.dependency.ModuleComponentArtifactIdentifier
+import org.nixos.gradle2nix.dependency.ModuleComponentIdentifier
+
+class DependencyVerificationConfiguration(
+    val trustedArtifacts: List<TrustCoordinates> = emptyList(),
+) {
+    data class TrustCoordinates internal constructor(
+        val group: String?,
+        val name: String?,
+        val version: String?,
+        val fileName: String?,
+        val isRegex: Boolean,
+        val reason: String?
+    ) : Comparable<TrustCoordinates> {
+
+        fun matches(id: ModuleComponentArtifactIdentifier): Boolean {
+            val moduleComponentIdentifier: ModuleComponentIdentifier = id.componentIdentifier
+            return (matches(group, moduleComponentIdentifier.group)
+                    && matches(name, moduleComponentIdentifier.module)
+                    && matches(version, moduleComponentIdentifier.version)
+                    && matches(fileName, id.fileName))
+        }
+
+        private fun matches(value: String?, expr: String): Boolean {
+            if (value == null) {
+                return true
+            }
+            return if (!isRegex) {
+                expr == value
+            } else expr.matches(value.toRegex())
+        }
+
+        override fun compareTo(other: TrustCoordinates): Int {
+            val regexComparison = isRegex.compareTo(other.isRegex)
+            if (regexComparison != 0) {
+                return regexComparison
+            }
+            val groupComparison = compareNullableStrings(
+                group, other.group
+            )
+            if (groupComparison != 0) {
+                return groupComparison
+            }
+            val nameComparison = compareNullableStrings(
+                name, other.name
+            )
+            if (nameComparison != 0) {
+                return nameComparison
+            }
+            val versionComparison = compareNullableStrings(
+                version, other.version
+            )
+            if (versionComparison != 0) {
+                return versionComparison
+            }
+            val fileNameComparison = compareNullableStrings(
+                fileName, other.fileName
+            )
+            return if (fileNameComparison != 0) {
+                fileNameComparison
+            } else compareNullableStrings(
+                reason, other.reason
+            )
+        }
+    }
+
+    companion object {
+        private fun compareNullableStrings(first: String?, second: String?): Int {
+            if (first == null) {
+                return if (second == null) {
+                    0
+                } else {
+                    -1
+                }
+            } else if (second == null) {
+                return 1
+            }
+            return first.compareTo(second)
+        }
+    }
+}

app/src/main/kotlin/org/nixos/gradle2nix/metadata/DependencyVerificationXmlTags.kt

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.nixos.gradle2nix.metadata
+
+internal object DependencyVerificationXmlTags {
+    const val ALSO_TRUST = "also-trust"
+    const val ARTIFACT = "artifact"
+    const val COMPONENT = "component"
+    const val COMPONENTS = "components"
+    const val CONFIG = "configuration"
+    const val ENABLED = "enabled"
+    const val FILE = "file"
+    const val GROUP = "group"
+    const val ID = "id"
+    const val IGNORED_KEY = "ignored-key"
+    const val IGNORED_KEYS = "ignored-keys"
+    const val KEY_SERVER = "key-server"
+    const val KEY_SERVERS = "key-servers"
+    const val NAME = "name"
+    const val ORIGIN = "origin"
+    const val PGP = "pgp"
+    const val REASON = "reason"
+    const val REGEX = "regex"
+    const val TRUST = "trust"
+    const val TRUSTED_ARTIFACTS = "trusted-artifacts"
+    const val TRUSTED_KEY = "trusted-key"
+    const val TRUSTED_KEYS = "trusted-keys"
+    const val TRUSTING = "trusting"
+    const val URI = "uri"
+    const val VALUE = "value"
+    const val VERIFICATION_METADATA = "verification-metadata"
+    const val VERIFY_METADATA = "verify-metadata"
+    const val VERIFY_SIGNATURES = "verify-signatures"
+    const val VERSION = "version"
+}

app/src/main/kotlin/org/nixos/gradle2nix/metadata/DependencyVerificationsXmlReader.kt

@@ -0,0 +1,421 @@
+/*
+ * Copyright 2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.nixos.gradle2nix.metadata
+
+import java.io.IOException
+import java.io.InputStream
+import javax.xml.parsers.ParserConfigurationException
+import javax.xml.parsers.SAXParser
+import javax.xml.parsers.SAXParserFactory
+import org.gradle.internal.UncheckedException
+import org.nixos.gradle2nix.dependency.DefaultModuleComponentArtifactIdentifier
+import org.nixos.gradle2nix.dependency.DefaultModuleComponentIdentifier
+import org.nixos.gradle2nix.dependency.DefaultModuleIdentifier
+import org.nixos.gradle2nix.dependency.ModuleComponentArtifactIdentifier
+import org.nixos.gradle2nix.dependency.ModuleComponentIdentifier
+import org.nixos.gradle2nix.dependency.ModuleIdentifier
+import org.nixos.gradle2nix.metadata.DependencyVerificationXmlTags.ALSO_TRUST
+import org.nixos.gradle2nix.metadata.DependencyVerificationXmlTags.ARTIFACT
+import org.nixos.gradle2nix.metadata.DependencyVerificationXmlTags.COMPONENT
+import org.nixos.gradle2nix.metadata.DependencyVerificationXmlTags.COMPONENTS
+import org.nixos.gradle2nix.metadata.DependencyVerificationXmlTags.CONFIG
+import org.nixos.gradle2nix.metadata.DependencyVerificationXmlTags.IGNORED_KEY
+import org.nixos.gradle2nix.metadata.DependencyVerificationXmlTags.IGNORED_KEYS
+import org.nixos.gradle2nix.metadata.DependencyVerificationXmlTags.KEY_SERVER
+import org.nixos.gradle2nix.metadata.DependencyVerificationXmlTags.KEY_SERVERS
+import org.nixos.gradle2nix.metadata.DependencyVerificationXmlTags.PGP
+import org.nixos.gradle2nix.metadata.DependencyVerificationXmlTags.TRUST
+import org.nixos.gradle2nix.metadata.DependencyVerificationXmlTags.TRUSTED_ARTIFACTS
+import org.nixos.gradle2nix.metadata.DependencyVerificationXmlTags.TRUSTED_KEY
+import org.nixos.gradle2nix.metadata.DependencyVerificationXmlTags.TRUSTED_KEYS
+import org.nixos.gradle2nix.metadata.DependencyVerificationXmlTags.TRUSTING
+import org.nixos.gradle2nix.metadata.DependencyVerificationXmlTags.VALUE
+import org.nixos.gradle2nix.metadata.DependencyVerificationXmlTags.VERIFICATION_METADATA
+import org.nixos.gradle2nix.metadata.DependencyVerificationXmlTags.VERIFY_METADATA
+import org.nixos.gradle2nix.metadata.DependencyVerificationXmlTags.VERIFY_SIGNATURES
+import org.xml.sax.Attributes
+import org.xml.sax.InputSource
+import org.xml.sax.SAXException
+import org.xml.sax.ext.DefaultHandler2
+
+object DependencyVerificationsXmlReader {
+    fun readFromXml(
+        input: InputStream,
+        builder: DependencyVerifierBuilder
+    ) {
+        try {
+            val saxParser = createSecureParser()
+            val xmlReader = saxParser.xmlReader
+            val handler = VerifiersHandler(builder)
+            xmlReader.setProperty("http://xml.org/sax/properties/lexical-handler", handler)
+            xmlReader.contentHandler = handler
+            xmlReader.parse(InputSource(input))
+        } catch (e: Exception) {
+            throw IllegalStateException(
+                "Unable to read dependency verification metadata",
+                e
+            )
+        } finally {
+            try {
+                input.close()
+            } catch (e: IOException) {
+                throw UncheckedException.throwAsUncheckedException(e)
+            }
+        }
+    }
+
+    fun readFromXml(input: InputStream): DependencyVerifier {
+        val builder = DependencyVerifierBuilder()
+        readFromXml(input, builder)
+        return builder.build()
+    }
+
+    @Throws(ParserConfigurationException::class, SAXException::class)
+    private fun createSecureParser(): SAXParser {
+        val spf = SAXParserFactory.newInstance()
+        spf.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false)
+        spf.setFeature("http://xml.org/sax/features/namespaces", false)
+        spf.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true)
+        return spf.newSAXParser()
+    }
+
+    private class VerifiersHandler(private val builder: DependencyVerifierBuilder) : DefaultHandler2() {
+        private var inMetadata = false
+        private var inComponents = false
+        private var inConfiguration = false
+        private var inVerifyMetadata = false
+        private var inVerifySignatures = false
+        private var inTrustedArtifacts = false
+        private var inKeyServers = false
+        private var inIgnoredKeys = false
+        private var inTrustedKeys = false
+        private var inTrustedKey = false
+        private var currentTrustedKey: String? = null
+        private var currentComponent: ModuleComponentIdentifier? = null
+        private var currentArtifact: ModuleComponentArtifactIdentifier? =
+            null
+        private var currentChecksum: ChecksumKind? = null
+
+        override fun startElement(uri: String, localName: String, qName: String, attributes: Attributes) {
+            when (qName) {
+                CONFIG -> inConfiguration =
+                    true
+
+                VERIFICATION_METADATA -> inMetadata =
+                    true
+
+                COMPONENTS -> {
+                    assertInMetadata()
+                    inComponents = true
+                }
+
+                COMPONENT -> {
+                    assertInComponents()
+                    currentComponent = createComponentId(attributes)
+                }
+
+                ARTIFACT -> {
+                    assertValidComponent()
+                    currentArtifact = createArtifactId(attributes)
+                }
+
+                VERIFY_METADATA -> {
+                    assertInConfiguration(VERIFY_METADATA)
+                    inVerifyMetadata = true
+                }
+
+                VERIFY_SIGNATURES -> {
+                    assertInConfiguration(VERIFY_SIGNATURES)
+                    inVerifySignatures = true
+                }
+
+                TRUSTED_ARTIFACTS -> {
+                    assertInConfiguration(TRUSTED_ARTIFACTS)
+                    inTrustedArtifacts = true
+                }
+
+                TRUSTED_KEY -> {
+                    assertContext(
+                        inTrustedKeys,
+                        TRUSTED_KEY,
+                        TRUSTED_KEYS
+                    )
+                    inTrustedKey = true
+                }
+
+                TRUSTED_KEYS -> {
+                    assertInConfiguration(TRUSTED_KEYS)
+                    inTrustedKeys = true
+                }
+
+                TRUST -> {
+                    assertInTrustedArtifacts()
+                    addTrustedArtifact(attributes)
+                }
+
+                TRUSTING -> {
+                    assertContext(
+                        inTrustedKey,
+                        TRUSTING,
+                        TRUSTED_KEY
+                    )
+                }
+
+                KEY_SERVERS -> {
+                    assertInConfiguration(KEY_SERVERS)
+                    inKeyServers = true
+                }
+
+                KEY_SERVER -> {
+                    assertContext(
+                        inKeyServers,
+                        KEY_SERVER,
+                        KEY_SERVERS
+                    )
+                }
+
+                IGNORED_KEYS -> {
+                    if (currentArtifact == null) {
+                        assertInConfiguration(IGNORED_KEYS)
+                    }
+                    inIgnoredKeys = true
+                }
+
+                IGNORED_KEY -> {
+                    assertContext(
+                        inIgnoredKeys,
+                        IGNORED_KEY,
+                        IGNORED_KEYS
+                    )
+                }
+
+                else -> if (currentChecksum != null && ALSO_TRUST == qName) {
+                    builder.addChecksum(
+                        currentArtifact!!,
+                        currentChecksum!!,
+                        getAttribute(attributes, VALUE),
+                        null,
+                        null
+                    )
+                } else if (currentArtifact != null) {
+                    if (PGP != qName) {
+                        currentChecksum = enumValueOf<ChecksumKind>(qName)
+                        builder.addChecksum(
+                            currentArtifact!!,
+                            currentChecksum!!,
+                            getAttribute(
+                                attributes,
+                                VALUE
+                            ),
+                            getNullableAttribute(
+                                attributes,
+                                DependencyVerificationXmlTags.ORIGIN
+                            ),
+                            getNullableAttribute(
+                                attributes,
+                                DependencyVerificationXmlTags.REASON
+                            )
+                        )
+                    }
+                }
+            }
+        }
+
+        private fun assertInTrustedArtifacts() {
+            assertContext(
+                inTrustedArtifacts,
+                TRUST,
+                TRUSTED_ARTIFACTS
+            )
+        }
+
+        private fun addTrustedArtifact(attributes: Attributes) {
+            var regex = false
+            val regexAttr = getNullableAttribute(
+                attributes,
+                DependencyVerificationXmlTags.REGEX
+            )
+            if (regexAttr != null) {
+                regex = regexAttr.toBoolean()
+            }
+            builder.addTrustedArtifact(
+                getNullableAttribute(
+                    attributes,
+                    DependencyVerificationXmlTags.GROUP
+                ),
+                getNullableAttribute(
+                    attributes,
+                    DependencyVerificationXmlTags.NAME
+                ),
+                getNullableAttribute(
+                    attributes,
+                    DependencyVerificationXmlTags.VERSION
+                ),
+                getNullableAttribute(
+                    attributes,
+                    DependencyVerificationXmlTags.FILE
+                ),
+                regex,
+                getNullableAttribute(
+                    attributes,
+                    DependencyVerificationXmlTags.REASON
+                )
+            )
+        }
+
+        private fun readBoolean(ch: CharArray, start: Int, length: Int): Boolean {
+            return String(ch, start, length).toBoolean()
+        }
+
+        private fun assertInConfiguration(tag: String) {
+            assertContext(
+                inConfiguration,
+                tag,
+                DependencyVerificationXmlTags.CONFIG
+            )
+        }
+
+        private fun assertInComponents() {
+            assertContext(
+                inComponents,
+                DependencyVerificationXmlTags.COMPONENT,
+                DependencyVerificationXmlTags.COMPONENTS
+            )
+        }
+
+        private fun assertInMetadata() {
+            assertContext(
+                inMetadata,
+                DependencyVerificationXmlTags.COMPONENTS,
+                DependencyVerificationXmlTags.VERIFICATION_METADATA
+            )
+        }
+
+        private fun assertValidComponent() {
+            assertContext(
+                currentComponent != null,
+                ARTIFACT,
+                DependencyVerificationXmlTags.COMPONENT
+            )
+        }
+
+        override fun endElement(uri: String, localName: String, qName: String) {
+            when (qName) {
+                DependencyVerificationXmlTags.CONFIG -> inConfiguration =
+                    false
+
+                VERIFY_METADATA -> inVerifyMetadata =
+                    false
+
+                VERIFY_SIGNATURES -> inVerifySignatures =
+                    false
+
+                DependencyVerificationXmlTags.VERIFICATION_METADATA -> inMetadata =
+                    false
+
+                DependencyVerificationXmlTags.COMPONENTS -> inComponents =
+                    false
+
+                DependencyVerificationXmlTags.COMPONENT -> currentComponent =
+                    null
+
+                TRUSTED_ARTIFACTS -> inTrustedArtifacts =
+                    false
+
+                TRUSTED_KEYS -> inTrustedKeys =
+                    false
+
+                TRUSTED_KEY -> {
+                    inTrustedKey = false
+                    currentTrustedKey = null
+                }
+
+                KEY_SERVERS -> inKeyServers =
+                    false
+
+                ARTIFACT -> {
+                    currentArtifact = null
+                    currentChecksum = null
+                }
+
+                IGNORED_KEYS -> inIgnoredKeys =
+                    false
+            }
+        }
+
+        private fun createArtifactId(attributes: Attributes): ModuleComponentArtifactIdentifier {
+            return DefaultModuleComponentArtifactIdentifier(
+                currentComponent!!,
+                getAttribute(
+                    attributes,
+                    DependencyVerificationXmlTags.NAME
+                )
+            )
+        }
+
+        private fun createComponentId(attributes: Attributes): ModuleComponentIdentifier {
+            return DefaultModuleComponentIdentifier(
+                createModuleId(attributes),
+                getAttribute(
+                    attributes,
+                    DependencyVerificationXmlTags.VERSION
+                )
+            )
+        }
+
+        private fun createModuleId(attributes: Attributes): ModuleIdentifier {
+            return DefaultModuleIdentifier(
+                getAttribute(
+                    attributes,
+                    DependencyVerificationXmlTags.GROUP
+                ),
+                getAttribute(
+                    attributes,
+                    DependencyVerificationXmlTags.NAME
+                )
+            )
+        }
+
+        private fun getAttribute(attributes: Attributes, name: String): String {
+            val value = attributes.getValue(name)
+            assertContext(
+                value != null,
+                "Missing attribute: $name"
+            )
+            return value.intern()
+        }
+
+        private fun getNullableAttribute(attributes: Attributes, name: String): String? {
+            val value = attributes.getValue(name) ?: return null
+            return value.intern()
+        }
+
+        companion object {
+            private fun assertContext(test: Boolean, innerTag: String, outerTag: String) {
+                assertContext(
+                    test,
+                    "<$innerTag> must be found under the <$outerTag> tag"
+                )
+            }
+
+            private fun assertContext(test: Boolean, message: String) {
+                if (!test) {
+                    throw IllegalStateException("Invalid dependency verification metadata file: $message")
+                }
+            }
+        }
+    }
+}

app/src/main/kotlin/org/nixos/gradle2nix/metadata/DependencyVerifier.kt

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.nixos.gradle2nix.metadata
+
+import org.nixos.gradle2nix.dependency.ModuleComponentIdentifier
+
+class DependencyVerifier internal constructor(
+    val verificationMetadata: Map<ModuleComponentIdentifier, ComponentVerificationMetadata>,
+    val configuration: DependencyVerificationConfiguration,
+)

app/src/main/kotlin/org/nixos/gradle2nix/metadata/DependencyVerifierBuilder.kt

@@ -0,0 +1,162 @@
+/*
+ * Copyright 2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.nixos.gradle2nix.metadata
+
+import org.nixos.gradle2nix.dependency.ModuleComponentArtifactIdentifier
+import org.nixos.gradle2nix.dependency.ModuleComponentIdentifier
+
+class DependencyVerifierBuilder {
+    private val byComponent: MutableMap<ModuleComponentIdentifier, ComponentVerificationsBuilder> = mutableMapOf()
+    private val trustedArtifacts: MutableList<DependencyVerificationConfiguration.TrustCoordinates> = mutableListOf()
+    
+    fun addChecksum(
+        artifact: ModuleComponentArtifactIdentifier,
+        kind: ChecksumKind,
+        value: String,
+        origin: String?,
+        reason: String?
+    ) {
+        val componentIdentifier: ModuleComponentIdentifier = artifact.componentIdentifier
+        byComponent.getOrPut(componentIdentifier) {
+            ComponentVerificationsBuilder(componentIdentifier)
+        }.addChecksum(artifact, kind, value, origin, reason)
+    }
+
+    @JvmOverloads
+    fun addTrustedArtifact(
+        group: String?,
+        name: String?,
+        version: String?,
+        fileName: String?,
+        regex: Boolean,
+        reason: String? = null
+    ) {
+        validateUserInput(group, name, version, fileName)
+        trustedArtifacts.add(DependencyVerificationConfiguration.TrustCoordinates(group, name, version, fileName, regex, reason))
+    }
+
+    private fun validateUserInput(
+        group: String?,
+        name: String?,
+        version: String?,
+        fileName: String?
+    ) {
+        // because this can be called from parsing XML, we need to perform additional verification
+        if (group == null && name == null && version == null && fileName == null) {
+            throw IllegalStateException("A trusted artifact must have at least one of group, name, version or file name not null")
+        }
+    }
+
+    fun build(): DependencyVerifier {
+        return DependencyVerifier(
+            byComponent
+                .toSortedMap(
+                    compareBy<ModuleComponentIdentifier> { it.group }
+                        .thenBy { it.module }
+                        .thenBy { it.version }
+                )
+                .mapValues { it.value.build() },
+            DependencyVerificationConfiguration(trustedArtifacts),
+        )
+    }
+
+    private class ComponentVerificationsBuilder(private val component: ModuleComponentIdentifier) {
+        private val byArtifact: MutableMap<String, ArtifactVerificationBuilder> = mutableMapOf()
+
+        fun addChecksum(
+            artifact: ModuleComponentArtifactIdentifier,
+            kind: ChecksumKind,
+            value: String,
+            origin: String?,
+            reason: String?
+        ) {
+            byArtifact.computeIfAbsent(artifact.fileName) { ArtifactVerificationBuilder() }
+                .addChecksum(kind, value, origin, reason)
+        }
+
+        fun build(): ComponentVerificationMetadata {
+            return ComponentVerificationMetadata(
+                component,
+                byArtifact
+                    .map { ArtifactVerificationMetadata(it.key, it.value.buildChecksums()) }
+                    .sortedBy { it.artifactName }
+            )
+        }
+    }
+
+    protected class ArtifactVerificationBuilder {
+        private val builder: MutableMap<ChecksumKind, ChecksumBuilder> = mutableMapOf()
+
+        fun addChecksum(kind: ChecksumKind, value: String, origin: String?, reason: String?) {
+            val builder = builder.getOrPut(kind) {
+                ChecksumBuilder(kind)
+            }
+            builder.addChecksum(value)
+            if (origin != null) {
+                builder.withOrigin(origin)
+            }
+            if (reason != null) {
+                builder.withReason(reason)
+            }
+        }
+
+        fun buildChecksums(): List<Checksum> {
+            return builder.values
+                .map(ChecksumBuilder::build)
+                .sortedBy { it.kind }
+        }
+    }
+
+    private class ChecksumBuilder(private val kind: ChecksumKind) {
+        private var value: String? = null
+        private var origin: String? = null
+        private var reason: String? = null
+        private var alternatives: MutableSet<String> = mutableSetOf()
+
+        /**
+         * Sets the origin, if not set already. This is
+         * mostly used for automatic generation of checksums
+         */
+        fun withOrigin(origin: String?) {
+            this.origin = this.origin ?: origin
+        }
+
+        /**
+         * Sets the reason, if not set already.
+         */
+        fun withReason(reason: String?) {
+            this.reason = this.reason ?: reason
+        }
+
+        fun addChecksum(checksum: String) {
+            if (value == null) {
+                value = checksum
+            } else if (value != checksum) {
+                alternatives.add(checksum)
+            }
+        }
+
+        fun build(): Checksum {
+            return Checksum(
+                kind,
+                checkNotNull(value) { "Checksum is null" },
+                alternatives,
+                origin,
+                reason
+            )
+        }
+    }
+}

app/src/test/kotlin/org/nixos/gradle2nix/BuildSrcTest.kt

@@ -1,19 +0,0 @@
-package org.nixos.gradle2nix
-
-import org.spekframework.spek2.Spek
-import org.spekframework.spek2.style.specification.describe
-import strikt.api.expectThat
-import strikt.assertions.containsKey
-
-object BuildSrcTest : Spek({
-    fixture("buildsrc/plugin-in-buildsrc/kotlin")
-    val fixture: Fixture by memoized()
-
-    describe("project with plugin in buildSrc") {
-        fixture.run()
-
-        it("should include buildSrc in gradle env", timeout = 0) {
-            expectThat(fixture.env()).containsKey("buildSrc")
-        }
-    }
-})

app/src/test/kotlin/org/nixos/gradle2nix/GoldenTest.kt

@@ -0,0 +1,40 @@
+package org.nixos.gradle2nix
+
+import io.kotest.core.spec.style.FunSpec
+
+class GoldenTest : FunSpec({
+    context("basic") {
+        golden("basic/basic-java-project")
+        golden("basic/basic-kotlin-project")
+    }
+    context("buildsrc") {
+        golden("buildsrc/plugin-in-buildsrc")
+    }
+    context("dependency") {
+        golden("dependency/classifier")
+        golden("dependency/maven-bom")
+        golden("dependency/snapshot")
+        golden("dependency/snapshot-dynamic")
+        golden("dependency/snapshot-redirect")
+    }
+    context("integration") {
+        golden("integration/settings-buildscript")
+    }
+    context("ivy") {
+        golden("ivy/basic")
+    }
+    context("plugin") {
+        golden("plugin/resolves-from-default-repo")
+    }
+    context("s3") {
+        golden("s3/maven")
+        golden("s3/maven-snapshot")
+    }
+    context("settings") {
+        golden("settings/buildscript")
+        golden("settings/dependency-resolution-management")
+    }
+    context("subprojects") {
+        golden("subprojects/multi-module")
+    }
+})

app/src/test/kotlin/org/nixos/gradle2nix/TestUtil.kt

@@ -1,60 +1,126 @@
 package org.nixos.gradle2nix
 
-import com.squareup.moshi.Moshi
+import io.kotest.assertions.fail
-import com.squareup.moshi.Types
+import io.kotest.common.ExperimentalKotest
-import okio.buffer
+import io.kotest.common.KotestInternal
-import okio.source
+import io.kotest.core.names.TestName
-import org.spekframework.spek2.dsl.Root
+import io.kotest.core.source.sourceRef
-import strikt.api.expectThat
+import io.kotest.core.spec.style.scopes.ContainerScope
-import strikt.assertions.exists
+import io.kotest.core.spec.style.scopes.RootScope
-import strikt.assertions.isNotNull
+import io.kotest.core.test.NestedTest
-import strikt.assertions.toPath
+import io.kotest.core.test.TestScope
+import io.kotest.core.test.TestType
+import io.kotest.extensions.system.withEnvironment
+import io.kotest.matchers.equals.beEqual
+import io.kotest.matchers.equals.shouldBeEqual
+import io.kotest.matchers.file.shouldBeAFile
+import io.kotest.matchers.paths.shouldBeAFile
+import io.kotest.matchers.should
+import java.io.File
+import java.io.FileFilter
 import java.nio.file.Files
 import java.nio.file.Path
 import java.nio.file.Paths
-import kotlin.io.path.ExperimentalPathApi
 import kotlin.io.path.createTempDirectory
+import kotlin.io.path.inputStream
+import kotlinx.serialization.ExperimentalSerializationApi
+import kotlinx.serialization.SerializationException
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.decodeFromStream
+import kotlinx.serialization.json.encodeToStream
+import okio.use
 
-private val moshi = Moshi.Builder().build()
+private val app = Gradle2Nix()
 
-class Fixture(val project: Path) {
+@OptIn(ExperimentalSerializationApi::class)
-    private val app = Main()
+private val json = Json {
-
+    prettyPrint = true
-    fun run(vararg args: String) {
+    prettyPrintIndent = "  "
-        app.main(args.toList() + project.toString())
-    }
-
-    fun env(): Map<String, NixGradleEnv> {
-        val file = (app.outDir ?: project.toFile()).resolve("${app.envFile}.json")
-        expectThat(file).toPath().exists()
-        val env = file.source().buffer().use { source ->
-            moshi
-                .adapter<Map<String, NixGradleEnv>>(
-                    Types.newParameterizedType(Map::class.java, String::class.java, NixGradleEnv::class.java)
-                ).fromJson(source)
-        }
-        expectThat(env).isNotNull()
-        return env!!
-    }
 }
 
-@OptIn(ExperimentalPathApi::class)
+@OptIn(ExperimentalKotest::class, ExperimentalSerializationApi::class, KotestInternal::class)
-fun Root.fixture(name: String) {
+suspend fun TestScope.fixture(
-    val fixture by memoized(
+    project: String,
-        factory = {
+    vararg args: String,
-            val url = checkNotNull(Thread.currentThread().contextClassLoader.getResource(name)?.toURI()) {
+    test: suspend TestScope.(Map<String, Map<String, Artifact>>) -> Unit
-                "$name: No test fixture found"
+) {
+    val tmp = Paths.get("build/tmp/gradle2nix").apply { toFile().mkdirs() }
+    val baseDir = Paths.get("../fixtures", project).toFile()
+    val children = baseDir.listFiles(FileFilter { it.isDirectory && (it.name == "groovy" || it.name == "kotlin") })
+        ?.toList()
+    val cases = if (children.isNullOrEmpty()) {
+        listOf(project to baseDir)
+    } else {
+        children.map { "$project.${it.name}" to it }
     }
-            val fixtureRoot = Paths.get(url)
+    for (case in cases) {
-            val dest = createTempDirectory("gradle2nix")
+        registerTestCase(
-            val src = checkNotNull(fixtureRoot.takeIf { Files.exists(it) }) {
+            NestedTest(
-                "$name: Test fixture not found: $fixtureRoot"
+                name = TestName(case.first),
+                disabled = false,
+                config = null,
+                type = TestType.Dynamic,
+                source = sourceRef()
+            ) {
+                var dirName = case.second.toString().replace("/", ".")
+                while (dirName.startsWith(".")) dirName = dirName.removePrefix(".")
+                while (dirName.endsWith(".")) dirName = dirName.removeSuffix(".")
+
+                val tempDir = File(tmp.toFile(), dirName)
+                tempDir.deleteRecursively()
+                case.second.copyRecursively(tempDir)
+
+                if (!tempDir.resolve("settings.gradle").exists() && !tempDir.resolve("settings.gradle.kts").exists()) {
+                    Files.createFile(tempDir.resolve("settings.gradle").toPath())
                 }
-            src.toFile().copyRecursively(dest.toFile())
+                app.main(listOf("-d", tempDir.toString()) + args.withM2())
-            Fixture(dest)
+                val file = tempDir.resolve("${app.envFile}.json")
-        },
+                file.shouldBeAFile()
-        destructor = {
+                val env: Map<String, Map<String, Artifact>> = file.inputStream().buffered().use { input ->
-            it.project.toFile().deleteRecursively()
+                    Json.decodeFromStream(input)
+                }
+                test(env)
             }
         )
+    }
+}
+
+val updateGolden = System.getProperty("org.nixos.gradle2nix.update-golden") != null
+
+@OptIn(ExperimentalSerializationApi::class)
+suspend fun TestScope.golden(
+    project: String,
+    vararg args: String,
+) {
+    fixture(project, *args) { env ->
+        val filename = "${testCase.name.testName}.json"
+        val goldenFile = File("../fixtures/golden/$filename")
+        if (updateGolden) {
+            goldenFile.parentFile.mkdirs()
+            goldenFile.outputStream().buffered().use { output ->
+                json.encodeToStream(env, output)
+            }
+        } else {
+            if (!goldenFile.exists()) {
+                fail("Golden file '$filename' doesn't exist. Run with --update-golden to generate.")
+            }
+            val goldenData: Map<String, Map<String, Artifact>> = try {
+                goldenFile.inputStream().buffered().use { input ->
+                    json.decodeFromStream(input)
+                }
+            } catch (e: SerializationException) {
+                fail("Failed to load golden data from '$filename'. Run with --update-golden to regenerate.")
+            }
+            env should beEqual(goldenData)
+        }
+    }
+}
+
+val m2 = System.getProperty("org.nixos.gradle2nix.m2")
+
+private fun Array<out String>.withM2(): List<String> {
+    val args = toMutableList()
+    if (args.indexOf("--") < 0) args.add("--")
+    args.add("-Dorg.nixos.gradle2nix.m2=$m2")
+    return args
 }

assets/gradle2nix.svg

@@ -5,7 +5,6 @@
     xmlns:dc="http://purl.org/dc/elements/1.1/"
     xmlns:cc="http://creativecommons.org/ns#"
     xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
     xmlns="http://www.w3.org/2000/svg"
     xmlns:xlink="http://www.w3.org/1999/xlink"
     xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"

build.gradle.kts

@@ -1,5 +1,11 @@
 plugins {
     base
+    alias(libs.plugins.kotlin.jvm) apply false
+    alias(libs.plugins.kotlin.serialization) apply false
+    alias(libs.plugins.ksp) apply false
+    alias(libs.plugins.pluginPublish) apply false
+    alias(libs.plugins.shadow) apply false
+    alias(libs.plugins.stutter) apply false
 }
 
 group = "org.nixos.gradle2nix"
@@ -10,37 +16,9 @@ subprojects {
     version = rootProject.version
 }
 
-allprojects {
-    plugins.withType<JavaBasePlugin> {
-        this@allprojects.withConvention(JavaPluginConvention::class) {
-            sourceSets.all {
-                configurations {
-                    named(compileClasspathConfigurationName) {
-                        resolutionStrategy.activateDependencyLocking()
-                    }
-                    named(runtimeClasspathConfigurationName) {
-                        resolutionStrategy.activateDependencyLocking()
-                    }
-                }
-            }
-
-            tasks.register("lock") {
-                doFirst {
-                    assert(gradle.startParameter.isWriteDependencyLocks)
-                    file("buildscript-gradle.lockfile").delete()
-                    file("gradle.lockfile").delete()
-                }
-                doLast {
-                    configurations.matching { it.isCanBeResolved }.all { resolve() }
-                }
-            }
-        }
-    }
-}
-
 tasks {
     wrapper {
-        gradleVersion = "6.8.1"
+        gradleVersion = "8.3"
         distributionType = Wrapper.DistributionType.ALL
     }
 }

fixtures/basic/basic-java-project/groovy/build.gradle

@@ -3,7 +3,6 @@ plugins {
 }
 
 repositories {
-    jcenter()
     mavenCentral()
 }
 

fixtures/basic/basic-java-project/kotlin/build.gradle.kts

@@ -3,7 +3,6 @@ plugins {
 }
 
 repositories {
-    jcenter()
     mavenCentral()
 }
 

fixtures/basic/basic-kotlin-project/kotlin/build.gradle.kts

@@ -1,13 +1,13 @@
-    val kotlinVersion = "1.3.61"
+val kotlinVersion = "1.6.21"
-    val spekVersion = "2.0.9"
+val spekVersion = "2.0.9"
 
-    plugins {
+plugins {
     application
-        kotlin("jvm") version "1.3.61"
+    kotlin("jvm") version "1.6.21"
-    }
+}
 
-    dependencies {
+dependencies {
-        compile(kotlin("stdlib"))
+    compileOnly(kotlin("stdlib"))
     implementation("com.natpryce:konfig:1.6.10.0")
     implementation("com.github.pengrad:java-telegram-bot-api:4.6.0")
     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.3")
@@ -22,9 +22,9 @@
     implementation("com.fasterxml.jackson.core:jackson-databind:2.10.1")
     testImplementation("org.spekframework.spek2:spek-dsl-jvm:$spekVersion")
     testRuntimeOnly("org.spekframework.spek2:spek-runner-junit5:$spekVersion")
-        testCompile("com.winterbe:expekt:0.5.0")
+    testCompileOnly("com.winterbe:expekt:0.5.0")
-    }
+}
 
-    repositories {
+repositories {
-        jcenter()
+    mavenCentral()
-    }
+}

fixtures/buildsrc/plugin-in-buildsrc/kotlin/build.gradle.kts

@@ -1,4 +1,4 @@
 plugins {
     `java-library`
-    id("com.example.custom-spotless")
+    id("com.example.apply-plugin-publish")
 }

fixtures/buildsrc/plugin-in-buildsrc/kotlin/buildSrc/build.gradle.kts

@@ -3,10 +3,9 @@ plugins {
 }
 
 repositories {
-    jcenter()
     gradlePluginPortal()
 }
 
 dependencies {
-    implementation("com.diffplug.spotless:spotless-plugin-gradle:3.28.1")
+    implementation("com.gradle.publish:plugin-publish-plugin:1.2.1")
 }

fixtures/buildsrc/plugin-in-buildsrc/kotlin/buildSrc/src/main/kotlin/com.example/apply-plugin-publish.gradle.kts

@@ -0,0 +1,5 @@
+package com.example
+
+plugins {
+    id("com.gradle.plugin-publish")
+}

fixtures/buildsrc/plugin-in-buildsrc/kotlin/buildSrc/src/main/kotlin/com.example/custom-spotless.gradle.kts

@@ -1,11 +0,0 @@
-package com.example
-
-plugins {
-    com.diffplug.gradle.spotless
-}
-
-spotless {
-    kotlin {
-        ktlint()
-    }
-}

fixtures/dependency/maven-bom/kotlin/build.gradle.kts

@@ -3,7 +3,7 @@ plugins {
 }
 
 repositories {
-    maven { url = uri("http://localhost:9999") }
+    maven { url = uri(System.getProperty("org.nixos.gradle2nix.m2")) }
 }
 
 dependencies {

fixtures/dependency/snapshot-dynamic/groovy/build.gradle

@@ -3,7 +3,7 @@ plugins {
 }
 
 repositories {
-    maven { url = uri("http://localhost:9999") }
+    maven { url = uri(System.getProperty("org.nixos.gradle2nix.m2")) }
 }
 
 dependencies {

fixtures/dependency/snapshot-dynamic/kotlin/build.gradle.kts

@@ -1,9 +1,10 @@
+
 plugins {
     java
 }
 
 repositories {
-    maven { url = uri("http://localhost:9999") }
+    maven { url = uri(System.getProperty("org.nixos.gradle2nix.m2")) }
 }
 
 dependencies {

fixtures/dependency/snapshot-redirect/groovy/build.gradle

@@ -3,7 +3,6 @@ plugins {
 }
 
 repositories {
-    jcenter()
     maven { url 'https://jitpack.io' }
 }
 

fixtures/dependency/snapshot/groovy/build.gradle

@@ -3,7 +3,7 @@ plugins {
 }
 
 repositories {
-    maven { url = uri("http://localhost:9999") }
+    maven { url = uri("file:/../../../../") }
 }
 
 dependencies {

fixtures/dependency/snapshot/kotlin/build.gradle.kts

@@ -1,9 +1,10 @@
+
 plugins {
     java
 }
 
 repositories {
-    maven { url = uri("http://localhost:9999") }
+    maven { url = uri(System.getProperty("org.nixos.gradle2nix.m2")) }
 }
 
 dependencies {

fixtures/golden/basic/basic-java-project.groovy.json

@@ -0,0 +1,72 @@
+{
+  "com.squareup.okio:okio:2.2.2": {
+    "okio-2.2.2.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/com/squareup/okio/okio/2.2.2/okio-2.2.2.jar"
+      ],
+      "hash": "sha256-5YyXQGprsROIk3UCmaxjxqoEs4trSerhv8rRpj75uhs="
+    },
+    "okio-2.2.2.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/com/squareup/okio/okio/2.2.2/okio-2.2.2.pom"
+      ],
+      "hash": "sha256-/WIZiPf2lXAlc13G3QkLAKIPOju413ynkDYHf2KbFAs="
+    }
+  },
+  "com.squareup.moshi:moshi:1.8.0": {
+    "moshi-1.8.0.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/com/squareup/moshi/moshi/1.8.0/moshi-1.8.0.jar"
+      ],
+      "hash": "sha256-Qv50bSaU6hH+agK+zZ2iyj2v6Xye/VCg+a9cRZbnSmo="
+    },
+    "moshi-1.8.0.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/com/squareup/moshi/moshi/1.8.0/moshi-1.8.0.pom"
+      ],
+      "hash": "sha256-FLuAWbnddiACWSkN+IfjfmaaB0qsnImUAePIEC/lII8="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-stdlib:1.2.60": {
+    "kotlin-stdlib-1.2.60.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib/1.2.60/kotlin-stdlib-1.2.60.jar"
+      ],
+      "hash": "sha256-ahMCmPUXGsUqHiSW9+rnhbb1ZBbqPMuZ5DRNBNg/8HE="
+    },
+    "kotlin-stdlib-1.2.60.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib/1.2.60/kotlin-stdlib-1.2.60.pom"
+      ],
+      "hash": "sha256-5jKJkgnmtMqrlA/YLk7GOjLjJkP4Fff6cJdkeJDXnxg="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-stdlib-common:1.2.60": {
+    "kotlin-stdlib-common-1.2.60.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib-common/1.2.60/kotlin-stdlib-common-1.2.60.jar"
+      ],
+      "hash": "sha256-CbQ3WgZc8SeryZjF3PIrFmTEWvQrSJSZ16j0+Kt5P7E="
+    },
+    "kotlin-stdlib-common-1.2.60.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib-common/1.2.60/kotlin-stdlib-common-1.2.60.pom"
+      ],
+      "hash": "sha256-gwwnrx4c8k8PUm6kV5AcQ/OMGbtvfl03Y8PSU98bjaE="
+    }
+  },
+  "org.jetbrains:annotations:13.0": {
+    "annotations-13.0.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/annotations/13.0/annotations-13.0.jar"
+      ],
+      "hash": "sha256-rOKhDcji1f00kl7KwD5JiLLA+FFlDJS4zvSbob0RFHg="
+    },
+    "annotations-13.0.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/annotations/13.0/annotations-13.0.pom"
+      ],
+      "hash": "sha256-llrrK+3/NpgZvd4b96CzuJuCR91pyIuGN112Fju4w5c="
+    }
+  }
+}

fixtures/golden/basic/basic-java-project.kotlin.json

@@ -0,0 +1,72 @@
+{
+  "com.squareup.okio:okio:2.2.2": {
+    "okio-2.2.2.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/com/squareup/okio/okio/2.2.2/okio-2.2.2.jar"
+      ],
+      "hash": "sha256-5YyXQGprsROIk3UCmaxjxqoEs4trSerhv8rRpj75uhs="
+    },
+    "okio-2.2.2.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/com/squareup/okio/okio/2.2.2/okio-2.2.2.pom"
+      ],
+      "hash": "sha256-/WIZiPf2lXAlc13G3QkLAKIPOju413ynkDYHf2KbFAs="
+    }
+  },
+  "com.squareup.moshi:moshi:1.8.0": {
+    "moshi-1.8.0.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/com/squareup/moshi/moshi/1.8.0/moshi-1.8.0.jar"
+      ],
+      "hash": "sha256-Qv50bSaU6hH+agK+zZ2iyj2v6Xye/VCg+a9cRZbnSmo="
+    },
+    "moshi-1.8.0.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/com/squareup/moshi/moshi/1.8.0/moshi-1.8.0.pom"
+      ],
+      "hash": "sha256-FLuAWbnddiACWSkN+IfjfmaaB0qsnImUAePIEC/lII8="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-stdlib:1.2.60": {
+    "kotlin-stdlib-1.2.60.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib/1.2.60/kotlin-stdlib-1.2.60.jar"
+      ],
+      "hash": "sha256-ahMCmPUXGsUqHiSW9+rnhbb1ZBbqPMuZ5DRNBNg/8HE="
+    },
+    "kotlin-stdlib-1.2.60.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib/1.2.60/kotlin-stdlib-1.2.60.pom"
+      ],
+      "hash": "sha256-5jKJkgnmtMqrlA/YLk7GOjLjJkP4Fff6cJdkeJDXnxg="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-stdlib-common:1.2.60": {
+    "kotlin-stdlib-common-1.2.60.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib-common/1.2.60/kotlin-stdlib-common-1.2.60.jar"
+      ],
+      "hash": "sha256-CbQ3WgZc8SeryZjF3PIrFmTEWvQrSJSZ16j0+Kt5P7E="
+    },
+    "kotlin-stdlib-common-1.2.60.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib-common/1.2.60/kotlin-stdlib-common-1.2.60.pom"
+      ],
+      "hash": "sha256-gwwnrx4c8k8PUm6kV5AcQ/OMGbtvfl03Y8PSU98bjaE="
+    }
+  },
+  "org.jetbrains:annotations:13.0": {
+    "annotations-13.0.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/annotations/13.0/annotations-13.0.jar"
+      ],
+      "hash": "sha256-rOKhDcji1f00kl7KwD5JiLLA+FFlDJS4zvSbob0RFHg="
+    },
+    "annotations-13.0.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/annotations/13.0/annotations-13.0.pom"
+      ],
+      "hash": "sha256-llrrK+3/NpgZvd4b96CzuJuCR91pyIuGN112Fju4w5c="
+    }
+  }
+}

fixtures/golden/buildsrc/plugin-in-buildsrc.kotlin.json

@@ -0,0 +1,576 @@
+{
+  "org.gradle.kotlin.kotlin-dsl:org.gradle.kotlin.kotlin-dsl.gradle.plugin:4.1.0": {
+    "org.gradle.kotlin.kotlin-dsl.gradle.plugin-4.1.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/gradle/kotlin/kotlin-dsl/org.gradle.kotlin.kotlin-dsl.gradle.plugin/4.1.0/org.gradle.kotlin.kotlin-dsl.gradle.plugin-4.1.0.pom"
+      ],
+      "hash": "sha256-PKFoMBmO4Pc//RRgknW3A5zR/seULCInsEX6JpbjV2c="
+    }
+  },
+  "org.gradle.kotlin:gradle-kotlin-dsl-plugins:4.1.0": {
+    "gradle-kotlin-dsl-plugins-4.1.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/gradle/kotlin/gradle-kotlin-dsl-plugins/4.1.0/gradle-kotlin-dsl-plugins-4.1.0.jar"
+      ],
+      "hash": "sha256-jpBY+e9xNsVaJKXPKgoZKNb9oYJ2JZ0KktaxAr8m1Cc="
+    },
+    "gradle-kotlin-dsl-plugins-4.1.0.module": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/gradle/kotlin/gradle-kotlin-dsl-plugins/4.1.0/gradle-kotlin-dsl-plugins-4.1.0.module"
+      ],
+      "hash": "sha256-0KuS4r6L+a8iIhAL4VOLP2R7SvA0+ZA1RJGKO4dxrq8="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.9.0": {
+    "kotlin-stdlib-jdk8-1.9.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.9.0/kotlin-stdlib-jdk8-1.9.0.jar"
+      ],
+      "hash": "sha256-pZ+iT98f+1lLrs2/D9EAEPl3zqECNtSH/jRkl3pzd/o="
+    },
+    "kotlin-stdlib-jdk8-1.9.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.9.0/kotlin-stdlib-jdk8-1.9.0.pom"
+      ],
+      "hash": "sha256-ZNWY3YjiUEZnMeIDBKtvBsu7urfuMitHA7a1n4gcT5I="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-stdlib:1.9.0": {
+    "kotlin-stdlib-1.9.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-stdlib/1.9.0/kotlin-stdlib-1.9.0.jar"
+      ],
+      "hash": "sha256-Na7/vi21qkRgcs7lD87ki3+p4vxRyjfAzH19C8OdlS4="
+    },
+    "kotlin-stdlib-1.9.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-stdlib/1.9.0/kotlin-stdlib-1.9.0.pom"
+      ],
+      "hash": "sha256-N3UiY/Ysw+MlCFbiiO5Kc9QQLXJqd2JwNPlIBsjBCso="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-stdlib-common:1.9.0": {
+    "kotlin-stdlib-common-1.9.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-stdlib-common/1.9.0/kotlin-stdlib-common-1.9.0.jar"
+      ],
+      "hash": "sha256-KDJ0IEvXwCB4nsRvj45yr0JE1/VQszkqV+XKAGrXqiw="
+    },
+    "kotlin-stdlib-common-1.9.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-stdlib-common/1.9.0/kotlin-stdlib-common-1.9.0.pom"
+      ],
+      "hash": "sha256-NmDTanD+s6vknxG5BjPkHTYnNXbwcbDhCdqbOg3wgqU="
+    }
+  },
+  "org.jetbrains:annotations:13.0": {
+    "annotations-13.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/annotations/13.0/annotations-13.0.jar"
+      ],
+      "hash": "sha256-rOKhDcji1f00kl7KwD5JiLLA+FFlDJS4zvSbob0RFHg="
+    },
+    "annotations-13.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/annotations/13.0/annotations-13.0.pom"
+      ],
+      "hash": "sha256-llrrK+3/NpgZvd4b96CzuJuCR91pyIuGN112Fju4w5c="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-stdlib-jdk7:1.9.0": {
+    "kotlin-stdlib-jdk7-1.9.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.9.0/kotlin-stdlib-jdk7-1.9.0.jar"
+      ],
+      "hash": "sha256-t5eaeqyUBV8Nnx/TtHzl/+HLYDKoQrqfvnGG8IUokXg="
+    },
+    "kotlin-stdlib-jdk7-1.9.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.9.0/kotlin-stdlib-jdk7-1.9.0.pom"
+      ],
+      "hash": "sha256-wRB08MiYqYuGPGFEcdQ409+Soewzgqbjf5NdfXGVS1o="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-gradle-plugin:1.9.0": {
+    "kotlin-gradle-plugin-1.9.0-gradle81.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin/1.9.0/kotlin-gradle-plugin-1.9.0-gradle81.jar"
+      ],
+      "hash": "sha256-2UOg4ntHRuAfg0BaSfUmoi9HGx2x1GOdb84m1xHv+/4="
+    },
+    "kotlin-gradle-plugin-1.9.0.module": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin/1.9.0/kotlin-gradle-plugin-1.9.0.module"
+      ],
+      "hash": "sha256-/mOWRe2PvcW8Et588lRopNsx52O6ea26ogahTeYP0xQ="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-gradle-plugin-api:1.9.0": {
+    "kotlin-gradle-plugin-api-1.9.0-gradle81.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin-api/1.9.0/kotlin-gradle-plugin-api-1.9.0-gradle81.jar"
+      ],
+      "hash": "sha256-AhbssMeA+V47EBoOlc/DZ/LvVrBvLeqqqZJaDxF8INk="
+    },
+    "kotlin-gradle-plugin-api-1.9.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin-api/1.9.0/kotlin-gradle-plugin-api-1.9.0.jar"
+      ],
+      "hash": "sha256-AhbssMeA+V47EBoOlc/DZ/LvVrBvLeqqqZJaDxF8INk="
+    },
+    "kotlin-gradle-plugin-api-1.9.0.module": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin-api/1.9.0/kotlin-gradle-plugin-api-1.9.0.module"
+      ],
+      "hash": "sha256-Gu1WWijZE0KsWkuhRsKFal67xjkoXFKVUhefr8dhTds="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-gradle-plugins-bom:1.9.0": {
+    "kotlin-gradle-plugins-bom-1.9.0.module": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugins-bom/1.9.0/kotlin-gradle-plugins-bom-1.9.0.module"
+      ],
+      "hash": "sha256-/SufabguQ8tQnwhBsYvzxd99q18eC+oDT8CypZnW4pY="
+    },
+    "kotlin-gradle-plugins-bom-1.9.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugins-bom/1.9.0/kotlin-gradle-plugins-bom-1.9.0.pom"
+      ],
+      "hash": "sha256-XTmtkDDf0zsLrCn3UAAJzmKHYulP5h8BF3rhNL24D6E="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-gradle-plugin-model:1.9.0": {
+    "kotlin-gradle-plugin-model-1.9.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin-model/1.9.0/kotlin-gradle-plugin-model-1.9.0.jar"
+      ],
+      "hash": "sha256-/wWqtoizSnmSp+NfncTewlhD8Tqelwrv5W3T4SKghBU="
+    },
+    "kotlin-gradle-plugin-model-1.9.0.module": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin-model/1.9.0/kotlin-gradle-plugin-model-1.9.0.module"
+      ],
+      "hash": "sha256-ZvS5FEcM80bgXQP4otWenHRvpu3PZMcS8XagiBqsPkk="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-tooling-core:1.9.0": {
+    "kotlin-tooling-core-1.9.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-tooling-core/1.9.0/kotlin-tooling-core-1.9.0.jar"
+      ],
+      "hash": "sha256-5TmiJCi5ysZ/dbLWHytuKnGDUNe7MYI8fcqJB/kJma4="
+    },
+    "kotlin-tooling-core-1.9.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-tooling-core/1.9.0/kotlin-tooling-core-1.9.0.pom"
+      ],
+      "hash": "sha256-KSbD/CFJWXAcjxYNjdyGn3s/pFKv3o3RdcjnwrvHBSI="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-sam-with-receiver:1.9.0": {
+    "kotlin-sam-with-receiver-1.9.0-gradle81.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-sam-with-receiver/1.9.0/kotlin-sam-with-receiver-1.9.0-gradle81.jar"
+      ],
+      "hash": "sha256-mK1U0XMRxg6FyGlDPV3TdpMTIDABJwCb5+nrsyH8xCs="
+    },
+    "kotlin-sam-with-receiver-1.9.0.module": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-sam-with-receiver/1.9.0/kotlin-sam-with-receiver-1.9.0.module"
+      ],
+      "hash": "sha256-GTPz8nsCrr/6LnvBmWN8TKg90xgHqjgwDLHh+jGsoiU="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-assignment:1.9.0": {
+    "kotlin-assignment-1.9.0-gradle81.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-assignment/1.9.0/kotlin-assignment-1.9.0-gradle81.jar"
+      ],
+      "hash": "sha256-mBdB+GlpwM4YQ1pcEJePJ3VGMxbOgqp/gmfsf2qfFNk="
+    },
+    "kotlin-assignment-1.9.0.module": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-assignment/1.9.0/kotlin-assignment-1.9.0.module"
+      ],
+      "hash": "sha256-kqBzm0y4NgSm3jddsKP+gTUDhZy8+aLtqZ++CXs8e9Y="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-gradle-plugin-annotations:1.9.0": {
+    "kotlin-gradle-plugin-annotations-1.9.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin-annotations/1.9.0/kotlin-gradle-plugin-annotations-1.9.0.jar"
+      ],
+      "hash": "sha256-KiZbNbx8VYIUJukbajzU9LkWOKC8fIffz+TgX36IRzg="
+    },
+    "kotlin-gradle-plugin-annotations-1.9.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin-annotations/1.9.0/kotlin-gradle-plugin-annotations-1.9.0.pom"
+      ],
+      "hash": "sha256-qjXuWp0dpZMV92nH/tsshwBWD1PFaAupKwsniBpKQnE="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-native-utils:1.9.0": {
+    "kotlin-native-utils-1.9.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-native-utils/1.9.0/kotlin-native-utils-1.9.0.jar"
+      ],
+      "hash": "sha256-D0gF93S/tcG20UXf5g09ILGu4ACJbOjs8+7/hM5EAjs="
+    },
+    "kotlin-native-utils-1.9.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-native-utils/1.9.0/kotlin-native-utils-1.9.0.pom"
+      ],
+      "hash": "sha256-Kazy3vkmve3Z6yBOx3Tnhq3Ek0EGqSlJAK81FVbn52o="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-util-io:1.9.0": {
+    "kotlin-util-io-1.9.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-util-io/1.9.0/kotlin-util-io-1.9.0.jar"
+      ],
+      "hash": "sha256-gdNtxt4/C+rwTDl6BrVoITujc6vO9Tlyt7gvYX1a9ws="
+    },
+    "kotlin-util-io-1.9.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-util-io/1.9.0/kotlin-util-io-1.9.0.pom"
+      ],
+      "hash": "sha256-BUBa+xn3tgbFKr6haJqi1ew9qQL+4teoV2lDOeSgQJQ="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-util-klib:1.9.0": {
+    "kotlin-util-klib-1.9.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-util-klib/1.9.0/kotlin-util-klib-1.9.0.jar"
+      ],
+      "hash": "sha256-wtxr820zabdzdVq4k3uX5Tmk1F04Fb7xm+36FUsS0xM="
+    },
+    "kotlin-util-klib-1.9.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-util-klib/1.9.0/kotlin-util-klib-1.9.0.pom"
+      ],
+      "hash": "sha256-acZHGaDgRjb2whMZ/lGKC1gieEu66P7YXmUfv6b4pFs="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-project-model:1.9.0": {
+    "kotlin-project-model-1.9.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-project-model/1.9.0/kotlin-project-model-1.9.0.jar"
+      ],
+      "hash": "sha256-rgk26bTGkh8D73eTYcrLu3XtKyIQR5+S9l8cushuNAw="
+    },
+    "kotlin-project-model-1.9.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-project-model/1.9.0/kotlin-project-model-1.9.0.pom"
+      ],
+      "hash": "sha256-6sHGTGAMYAJ7jmjfrTogPEFbn6IkWB1oz6Xnc+hWa3g="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-gradle-plugin-idea:1.9.0": {
+    "kotlin-gradle-plugin-idea-1.9.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin-idea/1.9.0/kotlin-gradle-plugin-idea-1.9.0.jar"
+      ],
+      "hash": "sha256-C7JszuNyr7m1hPKFfofMLz9TK2Kk9/pFdVjzr8Or6ZU="
+    },
+    "kotlin-gradle-plugin-idea-1.9.0.module": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin-idea/1.9.0/kotlin-gradle-plugin-idea-1.9.0.module"
+      ],
+      "hash": "sha256-pVg82bC0AS6VWtlhn7kBe1saosJRsFltr1M0kExcpls="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-gradle-plugin-idea-proto:1.9.0": {
+    "kotlin-gradle-plugin-idea-proto-1.9.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin-idea-proto/1.9.0/kotlin-gradle-plugin-idea-proto-1.9.0.jar"
+      ],
+      "hash": "sha256-54mY6iK81fVtE5gszBJMnHM3vRUHVMvcivKhSNdslwA="
+    },
+    "kotlin-gradle-plugin-idea-proto-1.9.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin-idea-proto/1.9.0/kotlin-gradle-plugin-idea-proto-1.9.0.pom"
+      ],
+      "hash": "sha256-QeElaFOKOjQHBMlww6T2D/WAH/3OQlymjKLAtHIhclA="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-klib-commonizer-api:1.9.0": {
+    "kotlin-klib-commonizer-api-1.9.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-klib-commonizer-api/1.9.0/kotlin-klib-commonizer-api-1.9.0.jar"
+      ],
+      "hash": "sha256-hd4ulysLtvRSjB90j0PEhmMUX8hTnsqWwT0bwNo/k10="
+    },
+    "kotlin-klib-commonizer-api-1.9.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-klib-commonizer-api/1.9.0/kotlin-klib-commonizer-api-1.9.0.pom"
+      ],
+      "hash": "sha256-hE+SCI/0j4v64lYh4yStw1d5CM9lD0/bJWlhC4+vaz4="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-build-tools-api:1.9.0": {
+    "kotlin-build-tools-api-1.9.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-build-tools-api/1.9.0/kotlin-build-tools-api-1.9.0.jar"
+      ],
+      "hash": "sha256-0ZyavegKnPQtJezJLLEUjtOhXu2yZy2qHkZubaWQ7sY="
+    },
+    "kotlin-build-tools-api-1.9.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-build-tools-api/1.9.0/kotlin-build-tools-api-1.9.0.pom"
+      ],
+      "hash": "sha256-iIFxmCZbm8BrPzSTWyv2qpj0gA7OvBzOQREN70m3pCE="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-compiler-embeddable:1.9.0": {
+    "kotlin-compiler-embeddable-1.9.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-compiler-embeddable/1.9.0/kotlin-compiler-embeddable-1.9.0.jar"
+      ],
+      "hash": "sha256-lTtQaR103SGf8/ZkRnDD5UnYfN/AphVPFgKmoKXf43M="
+    },
+    "kotlin-compiler-embeddable-1.9.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-compiler-embeddable/1.9.0/kotlin-compiler-embeddable-1.9.0.pom"
+      ],
+      "hash": "sha256-7jyHHO39bM9A0ESUQJbihlXeL5NF2ET+7GPMqcXkt8w="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-daemon-embeddable:1.9.0": {
+    "kotlin-daemon-embeddable-1.9.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-daemon-embeddable/1.9.0/kotlin-daemon-embeddable-1.9.0.jar"
+      ],
+      "hash": "sha256-lDGCoTfs1A5ikFjaUtszbO6bZm+AmWtlWELyCmNz35o="
+    },
+    "kotlin-daemon-embeddable-1.9.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-daemon-embeddable/1.9.0/kotlin-daemon-embeddable-1.9.0.pom"
+      ],
+      "hash": "sha256-OOMsu5GFenIGy/3cON1O4L5mX0CgEV/21NF348f4kq8="
+    }
+  },
+  "org.jetbrains.intellij.deps:trove4j:1.0.20200330": {
+    "trove4j-1.0.20200330.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/intellij/deps/trove4j/1.0.20200330/trove4j-1.0.20200330.jar"
+      ],
+      "hash": "sha256-xf1yW/+rUYRr88d9sTg8YKquv+G3/i8A0j/ht98KQ50="
+    },
+    "trove4j-1.0.20200330.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/intellij/deps/trove4j/1.0.20200330/trove4j-1.0.20200330.pom"
+      ],
+      "hash": "sha256-h3IcuqZaPJfYsbqdIHhA8WTJ/jh1n8nqEP/iZWX40+k="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-android-extensions:1.9.0": {
+    "kotlin-android-extensions-1.9.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-android-extensions/1.9.0/kotlin-android-extensions-1.9.0.jar"
+      ],
+      "hash": "sha256-IGdbuyp7aYKnFEUYpRi5qJZfkK6JuMmHiJgBIkSh6jM="
+    },
+    "kotlin-android-extensions-1.9.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-android-extensions/1.9.0/kotlin-android-extensions-1.9.0.pom"
+      ],
+      "hash": "sha256-WOHIg3JukUaVIDV95u0Xw/mSnI4IsRdKJ6OtbsDrzVI="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-compiler-runner:1.9.0": {
+    "kotlin-compiler-runner-1.9.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-compiler-runner/1.9.0/kotlin-compiler-runner-1.9.0.jar"
+      ],
+      "hash": "sha256-BbWlXUlJFhpxT838ZKXwTYejZMm73IZBs7t6VVfkPqo="
+    },
+    "kotlin-compiler-runner-1.9.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-compiler-runner/1.9.0/kotlin-compiler-runner-1.9.0.pom"
+      ],
+      "hash": "sha256-GIN9BlVntn5bzy4wTYWm4rbSRDz4En9AdnNKTo3yo2E="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-daemon-client:1.9.0": {
+    "kotlin-daemon-client-1.9.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-daemon-client/1.9.0/kotlin-daemon-client-1.9.0.jar"
+      ],
+      "hash": "sha256-WoyXfn3H8N4tka5Yva3CBBXe9M9dST5aGD+WxZeZAyA="
+    },
+    "kotlin-daemon-client-1.9.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-daemon-client/1.9.0/kotlin-daemon-client-1.9.0.pom"
+      ],
+      "hash": "sha256-sv50dBgjzM6JMXCWkg3LnOXBa460Z5jTn9jmdwPFidc="
+    }
+  },
+  "org.jetbrains.kotlinx:kotlinx-coroutines-core-jvm:1.5.0": {
+    "kotlinx-coroutines-core-jvm-1.5.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.5.0/kotlinx-coroutines-core-jvm-1.5.0.jar"
+      ],
+      "hash": "sha256-eNbMcTX4TWkv83Uvz9H6G74JQNffcGUuTx6u7Ax4r7s="
+    },
+    "kotlinx-coroutines-core-jvm-1.5.0.module": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.5.0/kotlinx-coroutines-core-jvm-1.5.0.module"
+      ],
+      "hash": "sha256-yIXdAoEHbFhDgm3jF+PLzcPYhZ2+71OuHPrNG5xg+W4="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-scripting-compiler-embeddable:1.9.0": {
+    "kotlin-scripting-compiler-embeddable-1.9.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-scripting-compiler-embeddable/1.9.0/kotlin-scripting-compiler-embeddable-1.9.0.jar"
+      ],
+      "hash": "sha256-Rp3RIGiVipevzhGIoBRFVM3tZ95aGqC/XKUwOfKdizY="
+    },
+    "kotlin-scripting-compiler-embeddable-1.9.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-scripting-compiler-embeddable/1.9.0/kotlin-scripting-compiler-embeddable-1.9.0.pom"
+      ],
+      "hash": "sha256-UJ5ikUwwvT43GcDgLk5Df8vxkRa4ouZYSPbUbFTsXJ4="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-scripting-compiler-impl-embeddable:1.9.0": {
+    "kotlin-scripting-compiler-impl-embeddable-1.9.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-scripting-compiler-impl-embeddable/1.9.0/kotlin-scripting-compiler-impl-embeddable-1.9.0.jar"
+      ],
+      "hash": "sha256-ZcUlbiyPvdpCbAMobmomgmfXEu+V7C05yVKSlXN4sE0="
+    },
+    "kotlin-scripting-compiler-impl-embeddable-1.9.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-scripting-compiler-impl-embeddable/1.9.0/kotlin-scripting-compiler-impl-embeddable-1.9.0.pom"
+      ],
+      "hash": "sha256-zaYp8KgbqcAKM95QJ/D4/7+fC45E5BlwNHdmu4WLTmM="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-scripting-common:1.9.0": {
+    "kotlin-scripting-common-1.9.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-scripting-common/1.9.0/kotlin-scripting-common-1.9.0.jar"
+      ],
+      "hash": "sha256-KFxBwO7tWaDn3LGIuJ+BVBR/vLvVNUcc9piWzNonP4Q="
+    },
+    "kotlin-scripting-common-1.9.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-scripting-common/1.9.0/kotlin-scripting-common-1.9.0.pom"
+      ],
+      "hash": "sha256-C/MG5PRe6xrDAk4pnUybcL4J7OmsAOcLL/mLPtQA8wc="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-scripting-jvm:1.9.0": {
+    "kotlin-scripting-jvm-1.9.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-scripting-jvm/1.9.0/kotlin-scripting-jvm-1.9.0.jar"
+      ],
+      "hash": "sha256-Zp3SvGBBjgdRU/2K2NllvlaetlwvMIOIyxEDud8TUVk="
+    },
+    "kotlin-scripting-jvm-1.9.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-scripting-jvm/1.9.0/kotlin-scripting-jvm-1.9.0.pom"
+      ],
+      "hash": "sha256-Ymj4BVjTX9qSRruneTKWkrlNWJWWVQfL6KhIkSxQ5yo="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-reflect:1.9.0": {
+    "kotlin-reflect-1.9.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-reflect/1.9.0/kotlin-reflect-1.9.0.jar"
+      ],
+      "hash": "sha256-IHAVm+UU6o6jziyLHueZPm/2CpNWWimfIAYpqn339YE="
+    },
+    "kotlin-reflect-1.9.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-reflect/1.9.0/kotlin-reflect-1.9.0.pom"
+      ],
+      "hash": "sha256-hXFWVnbRiXIEcTBs7ppV2RbAgDgvNabaaBk6x7EvTNs="
+    }
+  },
+  "com.gradle.publish:plugin-publish-plugin:1.2.1": {
+    "plugin-publish-plugin-1.2.1.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/com/gradle/publish/plugin-publish-plugin/1.2.1/plugin-publish-plugin-1.2.1.jar"
+      ],
+      "hash": "sha256-KY8MLpeVMhcaBaQWAyY3M7ZfiRE9ToCczQ4mmQFJ3hg="
+    },
+    "plugin-publish-plugin-1.2.1.module": {
+      "urls": [
+        "https://plugins.gradle.org/m2/com/gradle/publish/plugin-publish-plugin/1.2.1/plugin-publish-plugin-1.2.1.module"
+      ],
+      "hash": "sha256-w98uuag1ZdO2MVDYa0344o9mG1XOzdRJJ+RpMxA2yxk="
+    }
+  },
+  "org.apache.maven:maven-model:3.6.3": {
+    "maven-model-3.6.3.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/apache/maven/maven-model/3.6.3/maven-model-3.6.3.jar"
+      ],
+      "hash": "sha256-F87x9Y4UbvDX2elrO5LZih1v19KzKIulOOj/Hg2RYM8="
+    },
+    "maven-model-3.6.3.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/apache/maven/maven-model/3.6.3/maven-model-3.6.3.pom"
+      ],
+      "hash": "sha256-fHIOjLA9KFxxzW4zTZyeWWBivdMQ7grRX1xHmpkxVPA="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-script-runtime:1.9.0": {
+    "kotlin-script-runtime-1.9.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-script-runtime/1.9.0/kotlin-script-runtime-1.9.0.jar"
+      ],
+      "hash": "sha256-2E0MykEFD6wqlS0RBEc8Mpr/BMULNxMuV1SiCYCa3Z8="
+    },
+    "kotlin-script-runtime-1.9.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-script-runtime/1.9.0/kotlin-script-runtime-1.9.0.pom"
+      ],
+      "hash": "sha256-FNwHhdGUFP7sEgI91z64DIPQeIC3PlS48IqHj0I9seY="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-reflect:1.6.10": {
+    "kotlin-reflect-1.6.10.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-reflect/1.6.10/kotlin-reflect-1.6.10.jar"
+      ],
+      "hash": "sha256-MnesECrheq0QpVq+x1/1aWyNEJeQOWQ0tJbnUIeFQgM="
+    },
+    "kotlin-reflect-1.6.10.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-reflect/1.6.10/kotlin-reflect-1.6.10.pom"
+      ],
+      "hash": "sha256-V5BVJCdKAK4CiqzMJyg/a8WSWpNKBGwcxdBsjuTW1ak="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-sam-with-receiver-compiler-plugin-embeddable:1.9.0": {
+    "kotlin-sam-with-receiver-compiler-plugin-embeddable-1.9.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-sam-with-receiver-compiler-plugin-embeddable/1.9.0/kotlin-sam-with-receiver-compiler-plugin-embeddable-1.9.0.jar"
+      ],
+      "hash": "sha256-o7OlA4sNEybfGz/lvyCmaQnt1C3qa2P3BgCm8k/0VYw="
+    },
+    "kotlin-sam-with-receiver-compiler-plugin-embeddable-1.9.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-sam-with-receiver-compiler-plugin-embeddable/1.9.0/kotlin-sam-with-receiver-compiler-plugin-embeddable-1.9.0.pom"
+      ],
+      "hash": "sha256-WdgiTXgRi2RAwdRsCRzwLOWSnQaTU0hZnxP9wrmoU88="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-assignment-compiler-plugin-embeddable:1.9.0": {
+    "kotlin-assignment-compiler-plugin-embeddable-1.9.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-assignment-compiler-plugin-embeddable/1.9.0/kotlin-assignment-compiler-plugin-embeddable-1.9.0.jar"
+      ],
+      "hash": "sha256-MBY6DUXnN9gHW0kI0PCv8DXvqGa+iFIvQ37Jbg43KZQ="
+    },
+    "kotlin-assignment-compiler-plugin-embeddable-1.9.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-assignment-compiler-plugin-embeddable/1.9.0/kotlin-assignment-compiler-plugin-embeddable-1.9.0.pom"
+      ],
+      "hash": "sha256-HDfsoLIO1JYF6lVsonWq8eyZUaKZge4TNxZYP2pD4J8="
+    }
+  }
+}

fixtures/golden/dependency/classifier.groovy.json

@@ -0,0 +1,16 @@
+{
+  "com.badlogicgames.gdx:gdx-platform:1.9.9": {
+    "gdx-platform-1.9.9-natives-desktop.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/com/badlogicgames/gdx/gdx-platform/1.9.9/gdx-platform-1.9.9-natives-desktop.jar"
+      ],
+      "hash": "sha256-e8c9VPpFH+LeJU6PgmCkOb/jutOxFnO6LPMaTxL2hU8="
+    },
+    "gdx-platform-1.9.9.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/com/badlogicgames/gdx/gdx-platform/1.9.9/gdx-platform-1.9.9.pom"
+      ],
+      "hash": "sha256-SWnDZyJaErav4Z4sA+D1WA3U1aQOSR64sd8+cQzofSY="
+    }
+  }
+}

fixtures/golden/dependency/classifier.kotlin.json

@@ -0,0 +1,16 @@
+{
+  "com.badlogicgames.gdx:gdx-platform:1.9.9": {
+    "gdx-platform-1.9.9-natives-desktop.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/com/badlogicgames/gdx/gdx-platform/1.9.9/gdx-platform-1.9.9-natives-desktop.jar"
+      ],
+      "hash": "sha256-e8c9VPpFH+LeJU6PgmCkOb/jutOxFnO6LPMaTxL2hU8="
+    },
+    "gdx-platform-1.9.9.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/com/badlogicgames/gdx/gdx-platform/1.9.9/gdx-platform-1.9.9.pom"
+      ],
+      "hash": "sha256-SWnDZyJaErav4Z4sA+D1WA3U1aQOSR64sd8+cQzofSY="
+    }
+  }
+}

fixtures/golden/dependency/maven-bom.kotlin.json

@@ -0,0 +1,38 @@
+{
+  "io.micrometer:micrometer-bom:1.5.1": {
+    "micrometer-bom-1.5.1.pom": {
+      "urls": [
+        "file:/home/tad/proj/gradle2nix/fixtures/repositories/m2/io/micrometer/micrometer-bom/1.5.1/micrometer-bom-1.5.1.pom"
+      ],
+      "hash": "sha256-K/qF6ds8ck5sWvelJBYk+w+K04oQpT/4BtY57WVLRUI="
+    }
+  },
+  "io.micrometer:micrometer-core:1.5.1": {
+    "micrometer-core-1.5.1.jar": {
+      "urls": [
+        "file:/home/tad/proj/gradle2nix/fixtures/repositories/m2/io/micrometer/micrometer-core/1.5.1/micrometer-core-1.5.1.jar"
+      ],
+      "hash": "sha256-DtgVYBDVGDBWMwSfeKC6O+fwqd+N2q4eTizJgQ1wfI8="
+    },
+    "micrometer-core-1.5.1.pom": {
+      "urls": [
+        "file:/home/tad/proj/gradle2nix/fixtures/repositories/m2/io/micrometer/micrometer-core/1.5.1/micrometer-core-1.5.1.pom"
+      ],
+      "hash": "sha256-Cb4KaUHaOvdOz7VpDax6kJKuT2KWY5Ci73foX2xl6xw="
+    }
+  },
+  "org.hdrhistogram:HdrHistogram:2.1.12": {
+    "HdrHistogram-2.1.12.jar": {
+      "urls": [
+        "file:/home/tad/proj/gradle2nix/fixtures/repositories/m2/org/hdrhistogram/HdrHistogram/2.1.12/HdrHistogram-2.1.12.jar"
+      ],
+      "hash": "sha256-47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU="
+    },
+    "HdrHistogram-2.1.12.pom": {
+      "urls": [
+        "file:/home/tad/proj/gradle2nix/fixtures/repositories/m2/org/hdrhistogram/HdrHistogram/2.1.12/HdrHistogram-2.1.12.pom"
+      ],
+      "hash": "sha256-f7PnkMFU0bXiMXC7jL9/cO8ICa8XIp8dywENd5llEIA="
+    }
+  }
+}

fixtures/golden/dependency/snapshot-dynamic.groovy.json

@@ -0,0 +1,2 @@
+{
+}

fixtures/golden/dependency/snapshot-dynamic.kotlin.json

@@ -0,0 +1,2 @@
+{
+}

fixtures/golden/dependency/snapshot-redirect.groovy.json

@@ -0,0 +1,16 @@
+{
+  "com.github.anuken:packr:-SNAPSHOT:packr-1.2-g034efe5-114": {
+    "packr--SNAPSHOT.pom": {
+      "urls": [
+        "https://jitpack.io/com/github/anuken/packr/-SNAPSHOT/packr--SNAPSHOT.pom"
+      ],
+      "hash": "sha256-xP28J7blX1IzuJxD4u/wy1ZbwAT5RAajBcpBWs1fAxU="
+    },
+    "packr--SNAPSHOT.jar": {
+      "urls": [
+        "https://jitpack.io/com/github/anuken/packr/-SNAPSHOT/packr--SNAPSHOT.jar"
+      ],
+      "hash": "sha256-XrfVZLc7efr2n3Bz6mOw8DkRI0T8rU8B/MKUMVDl71w="
+    }
+  }
+}

fixtures/golden/dependency/snapshot.groovy.json

@@ -0,0 +1,2 @@
+{
+}

fixtures/golden/dependency/snapshot.kotlin.json

@@ -0,0 +1,2 @@
+{
+}

fixtures/golden/integration/settings-buildscript.groovy.json

@@ -0,0 +1,128 @@
+{
+  "gradle.plugin.net.vivin:gradle-semantic-build-versioning:4.0.0": {
+    "gradle-semantic-build-versioning-4.0.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/gradle/plugin/net/vivin/gradle-semantic-build-versioning/4.0.0/gradle-semantic-build-versioning-4.0.0.jar"
+      ],
+      "hash": "sha256-UTjmfOjgGUN4ALk8n2+dD8vr763Jb7xOvAl1yZomHvg="
+    },
+    "gradle-semantic-build-versioning-4.0.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/gradle/plugin/net/vivin/gradle-semantic-build-versioning/4.0.0/gradle-semantic-build-versioning-4.0.0.pom"
+      ],
+      "hash": "sha256-TygodBYH7RAtletfGJ1JbHhA7UY6zqifHlGmBWdxTvc="
+    }
+  },
+  "org.eclipse.jgit:org.eclipse.jgit:4.8.0.201706111038-r": {
+    "org.eclipse.jgit-4.8.0.201706111038-r.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/eclipse/jgit/org.eclipse.jgit/4.8.0.201706111038-r/org.eclipse.jgit-4.8.0.201706111038-r.jar"
+      ],
+      "hash": "sha256-SdkS6NXM4N0I3KPTkBiduGkqj34zY8274YJYFGIACro="
+    },
+    "org.eclipse.jgit-4.8.0.201706111038-r.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/eclipse/jgit/org.eclipse.jgit/4.8.0.201706111038-r/org.eclipse.jgit-4.8.0.201706111038-r.pom"
+      ],
+      "hash": "sha256-pVap9a38avSbKhLnLcPNfkPbj9whbA81iFlyovWton0="
+    }
+  },
+  "com.jcraft:jsch:0.1.54": {
+    "jsch-0.1.54.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/com/jcraft/jsch/0.1.54/jsch-0.1.54.jar"
+      ],
+      "hash": "sha256-kusnOjMWdiR4/dT+A6DOGELFb0lsnBL+EjXbgEUOH9s="
+    },
+    "jsch-0.1.54.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/com/jcraft/jsch/0.1.54/jsch-0.1.54.pom"
+      ],
+      "hash": "sha256-q49RIDm+f2riDhjnQ7Sp2KIJWElEMZF9pYrlqu+KNHg="
+    }
+  },
+  "com.googlecode.javaewah:JavaEWAH:1.1.6": {
+    "JavaEWAH-1.1.6.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/com/googlecode/javaewah/JavaEWAH/1.1.6/JavaEWAH-1.1.6.jar"
+      ],
+      "hash": "sha256-941EoeOHfxznSLSoXfUXHl6Omlw8b2O7kAPbb4TM6VI="
+    },
+    "JavaEWAH-1.1.6.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/com/googlecode/javaewah/JavaEWAH/1.1.6/JavaEWAH-1.1.6.pom"
+      ],
+      "hash": "sha256-f0/5GbHuF783duBYo/IOYXPbI6XkTPLRB+x1cMGGq/A="
+    }
+  },
+  "org.apache.httpcomponents:httpclient:4.3.6": {
+    "httpclient-4.3.6.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/apache/httpcomponents/httpclient/4.3.6/httpclient-4.3.6.jar"
+      ],
+      "hash": "sha256-eYONnq73PU+FLGOkgIMMOi1LWQ8Ks66BWkiUY+RxQAQ="
+    },
+    "httpclient-4.3.6.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/apache/httpcomponents/httpclient/4.3.6/httpclient-4.3.6.pom"
+      ],
+      "hash": "sha256-0CY09hMekUlhwCqoNnEeuscnBLJ+JsW9Iju62JsbZMM="
+    }
+  },
+  "org.apache.httpcomponents:httpcore:4.3.3": {
+    "httpcore-4.3.3.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/apache/httpcomponents/httpcore/4.3.3/httpcore-4.3.3.jar"
+      ],
+      "hash": "sha256-UoXegK8WUcSJMTuRqfQMZaTNy2s73nFvzAKNFoaaWpM="
+    },
+    "httpcore-4.3.3.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/apache/httpcomponents/httpcore/4.3.3/httpcore-4.3.3.pom"
+      ],
+      "hash": "sha256-tCf3z2fHWk4/niEI01v0UwNXPBRex3j8rc/6zvF6EmQ="
+    }
+  },
+  "commons-logging:commons-logging:1.1.3": {
+    "commons-logging-1.1.3.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/commons-logging/commons-logging/1.1.3/commons-logging-1.1.3.jar"
+      ],
+      "hash": "sha256-cJA/b8gumQjI2p8gRD9h2Q8IcKMSZCmR/oRioLk5F4Q="
+    },
+    "commons-logging-1.1.3.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/commons-logging/commons-logging/1.1.3/commons-logging-1.1.3.pom"
+      ],
+      "hash": "sha256-MlCsOsa9YO0GMfXNAzUDKymT1j5AWmrgVV0np+SGWEk="
+    }
+  },
+  "commons-codec:commons-codec:1.6": {
+    "commons-codec-1.6.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/commons-codec/commons-codec/1.6/commons-codec-1.6.jar"
+      ],
+      "hash": "sha256-VLNOlBuOFBS9PkDXNu/TSBdy3CbbMpb2qkXOyfYgPYY="
+    },
+    "commons-codec-1.6.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/commons-codec/commons-codec/1.6/commons-codec-1.6.pom"
+      ],
+      "hash": "sha256-oG410//zprgT2UiU6/PkmPlUDIZMWzmueDkH46bHKIk="
+    }
+  },
+  "org.slf4j:slf4j-api:1.7.2": {
+    "slf4j-api-1.7.2.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/slf4j/slf4j-api/1.7.2/slf4j-api-1.7.2.jar"
+      ],
+      "hash": "sha256-O654m0ATM7Kh0WA7f6Vz4ZkIYoGRcHID9utwjN7iwFI="
+    },
+    "slf4j-api-1.7.2.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/slf4j/slf4j-api/1.7.2/slf4j-api-1.7.2.pom"
+      ],
+      "hash": "sha256-LqynGv4KFRb0q9jp/5B4ONJo84yBw6VCzOjX87h8XUw="
+    }
+  }
+}

fixtures/golden/ivy/basic.kotlin.json

@@ -0,0 +1,30 @@
+{
+  "org.opendof.core-java:dof-cipher-sms4:1.0": {
+    "dof-cipher-sms4-1.0.jar": {
+      "urls": [
+        "https://asset.opendof.org/artifact/org.opendof.core-java/dof-cipher-sms4/1.0/dof-cipher-sms4-1.0.jar"
+      ],
+      "hash": "sha256-/Joo51NA6nBPEwFuFcnDc10JQZDE8P3jF3P4gl0vpMA="
+    },
+    "ivy-1.0.xml": {
+      "urls": [
+        "https://asset.opendof.org/ivy2/org.opendof.core-java/dof-cipher-sms4/1.0/ivy.xml"
+      ],
+      "hash": "sha256-rh+pQpXqPP/cmBD8slvwMrKlWCUb3JNzW3l58hd7oJ8="
+    }
+  },
+  "org.opendof.core-java:dof-oal:7.0.2": {
+    "dof-oal-7.0.2.jar": {
+      "urls": [
+        "https://asset.opendof.org/artifact/org.opendof.core-java/dof-oal/7.0.2/dof-oal-7.0.2.jar"
+      ],
+      "hash": "sha256-u+FUhQGBA8MRl28mXMTSnZ2HY2ysPHq7h9lANmHBK40="
+    },
+    "ivy-7.0.2.xml": {
+      "urls": [
+        "https://asset.opendof.org/ivy2/org.opendof.core-java/dof-oal/7.0.2/ivy.xml"
+      ],
+      "hash": "sha256-KZoUVyoDcfH/B/9V1SVqNiA/XIb3zlwoJkjb/jD+xig="
+    }
+  }
+}

fixtures/golden/plugin/resolves-from-default-repo.groovy.json

@@ -0,0 +1,494 @@
+{
+  "org.jetbrains.kotlin.jvm:org.jetbrains.kotlin.jvm.gradle.plugin:1.7.21": {
+    "org.jetbrains.kotlin.jvm.gradle.plugin-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/jvm/org.jetbrains.kotlin.jvm.gradle.plugin/1.7.21/org.jetbrains.kotlin.jvm.gradle.plugin-1.7.21.pom"
+      ],
+      "hash": "sha256-18S+c5nTziimR77ivh3nCwUdpLqoz9X4KYNDJ2UKD30="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-gradle-plugin:1.7.21": {
+    "kotlin-gradle-plugin-1.7.21-gradle71.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin/1.7.21/kotlin-gradle-plugin-1.7.21-gradle71.jar"
+      ],
+      "hash": "sha256-P12cqfSxiGOZjcVpNIk9m1ICRRzucJ+uuXbI+rI2cyI="
+    },
+    "kotlin-gradle-plugin-1.7.21.module": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin/1.7.21/kotlin-gradle-plugin-1.7.21.module"
+      ],
+      "hash": "sha256-j6I2KYtJBynes0XjG8ZPKSj3wbXxwjH8ZtvINlnBZ+E="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-gradle-plugin-api:1.7.21": {
+    "kotlin-gradle-plugin-api-1.7.21-gradle71.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin-api/1.7.21/kotlin-gradle-plugin-api-1.7.21-gradle71.jar"
+      ],
+      "hash": "sha256-rflytT2LY7s2jZA88y6bB+pTZW6PnaXxDfuv03gxviE="
+    },
+    "kotlin-gradle-plugin-api-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin-api/1.7.21/kotlin-gradle-plugin-api-1.7.21.jar"
+      ],
+      "hash": "sha256-rflytT2LY7s2jZA88y6bB+pTZW6PnaXxDfuv03gxviE="
+    },
+    "kotlin-gradle-plugin-api-1.7.21.module": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin-api/1.7.21/kotlin-gradle-plugin-api-1.7.21.module"
+      ],
+      "hash": "sha256-zGXnGhweng0JaG9cpJGORShIY1q7VCl15HwYlnw6A10="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-native-utils:1.7.21": {
+    "kotlin-native-utils-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-native-utils/1.7.21/kotlin-native-utils-1.7.21.jar"
+      ],
+      "hash": "sha256-k1KYF/2Nj9hlItZqqtyr0UKhcueMz+uUnNKJ40xw+Qs="
+    },
+    "kotlin-native-utils-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-native-utils/1.7.21/kotlin-native-utils-1.7.21.pom"
+      ],
+      "hash": "sha256-CEYFdUhagoAZC0g8H3fyCk063IegIXTzDuxVdNm65FY="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-util-io:1.7.21": {
+    "kotlin-util-io-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-util-io/1.7.21/kotlin-util-io-1.7.21.jar"
+      ],
+      "hash": "sha256-7MKI4AQqAUdgOeILbOXgaRj+8fic+J9V39KO8Xwm800="
+    },
+    "kotlin-util-io-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-util-io/1.7.21/kotlin-util-io-1.7.21.pom"
+      ],
+      "hash": "sha256-ziTM1kPWW+8Cey9uINCnkhdq29ug2eVVmS5CR6Y3Ne8="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-project-model:1.7.21": {
+    "kotlin-project-model-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-project-model/1.7.21/kotlin-project-model-1.7.21.jar"
+      ],
+      "hash": "sha256-4htTvrj3SxM6Y4mClPSlfcSiKJvoVfZrD5rosVYjFT8="
+    },
+    "kotlin-project-model-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-project-model/1.7.21/kotlin-project-model-1.7.21.pom"
+      ],
+      "hash": "sha256-JQfT7SKoHyssNSxMUOY1MivHEQClFQJN0NtQRifJ8Bs="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-tooling-core:1.7.21": {
+    "kotlin-tooling-core-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-tooling-core/1.7.21/kotlin-tooling-core-1.7.21.jar"
+      ],
+      "hash": "sha256-N5fxg1NC+8EuycHU+YMyugKCkaMyUakHySJ9j9lK7kg="
+    },
+    "kotlin-tooling-core-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-tooling-core/1.7.21/kotlin-tooling-core-1.7.21.pom"
+      ],
+      "hash": "sha256-tw2g1Eorhw7Lz85ZcMMOOOLs3htfQqHdRC0TA5gSKUY="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-gradle-plugin-model:1.7.21": {
+    "kotlin-gradle-plugin-model-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin-model/1.7.21/kotlin-gradle-plugin-model-1.7.21.jar"
+      ],
+      "hash": "sha256-FNP/F7o8tMi+uK3297QFB4gTS4kbsTyr5yPIwQ0dDhg="
+    },
+    "kotlin-gradle-plugin-model-1.7.21.module": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin-model/1.7.21/kotlin-gradle-plugin-model-1.7.21.module"
+      ],
+      "hash": "sha256-kCJoZCp1guVF4xgQnjdIw3WxOLCKFVuBX2yAi7vuR7U="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-gradle-plugin-idea:1.7.21": {
+    "kotlin-gradle-plugin-idea-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin-idea/1.7.21/kotlin-gradle-plugin-idea-1.7.21.jar"
+      ],
+      "hash": "sha256-C1dqyzeBqctWEKphxbev3zKQ/C2digzUv+FTe4dcReY="
+    },
+    "kotlin-gradle-plugin-idea-1.7.21.module": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin-idea/1.7.21/kotlin-gradle-plugin-idea-1.7.21.module"
+      ],
+      "hash": "sha256-ygHy2JJMcpaXMax+oVbwi7GP60LDEAClIj2dwW1ZuTg="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-gradle-plugin-idea-proto:1.7.21": {
+    "kotlin-gradle-plugin-idea-proto-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin-idea-proto/1.7.21/kotlin-gradle-plugin-idea-proto-1.7.21.jar"
+      ],
+      "hash": "sha256-NZhwZybLzo0oE05oiZw9WAv3LH6/kJcUHY28rtgnmHg="
+    },
+    "kotlin-gradle-plugin-idea-proto-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin-idea-proto/1.7.21/kotlin-gradle-plugin-idea-proto-1.7.21.pom"
+      ],
+      "hash": "sha256-PRwDYK9odF8qAyoMAYR//Pnriq1wa/ZZydhAoYTsXyM="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-util-klib:1.7.21": {
+    "kotlin-util-klib-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-util-klib/1.7.21/kotlin-util-klib-1.7.21.jar"
+      ],
+      "hash": "sha256-UgkkU0RkIN+7h4BN6s6yGfVI53fm3xK35wRKOmaHEgs="
+    },
+    "kotlin-util-klib-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-util-klib/1.7.21/kotlin-util-klib-1.7.21.pom"
+      ],
+      "hash": "sha256-D8d7J3Rc+kzuX+AA5tEpmtSUT3rMB4A7u8ws0rAT3oU="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-klib-commonizer-api:1.7.21": {
+    "kotlin-klib-commonizer-api-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-klib-commonizer-api/1.7.21/kotlin-klib-commonizer-api-1.7.21.jar"
+      ],
+      "hash": "sha256-MOGWrbAAH9F7ZgNe2QcNPw5Hui0ycTt1wwPGt7e3FeI="
+    },
+    "kotlin-klib-commonizer-api-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-klib-commonizer-api/1.7.21/kotlin-klib-commonizer-api-1.7.21.pom"
+      ],
+      "hash": "sha256-so6g3vy5lNH7U6e7olh9J0DG0mAXk2UglP1ox0Ul0CA="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-compiler-embeddable:1.7.21": {
+    "kotlin-compiler-embeddable-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-compiler-embeddable/1.7.21/kotlin-compiler-embeddable-1.7.21.jar",
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-compiler-embeddable/1.7.21/kotlin-compiler-embeddable-1.7.21.jar"
+      ],
+      "hash": "sha256-Ty5JK8x5XgaA4/h67qGtrp8wbK9SBAuUpvoPiP2skvk="
+    },
+    "kotlin-compiler-embeddable-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-compiler-embeddable/1.7.21/kotlin-compiler-embeddable-1.7.21.pom",
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-compiler-embeddable/1.7.21/kotlin-compiler-embeddable-1.7.21.pom"
+      ],
+      "hash": "sha256-CwIzMip2MO/eEzUmjkYSPw1tNjg5gg/TfE7Lbv+njjs="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-daemon-embeddable:1.7.21": {
+    "kotlin-daemon-embeddable-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-daemon-embeddable/1.7.21/kotlin-daemon-embeddable-1.7.21.jar",
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-daemon-embeddable/1.7.21/kotlin-daemon-embeddable-1.7.21.jar"
+      ],
+      "hash": "sha256-A+bwJUNSJIlOSe5e2EfLCwtKh540z6uQ1wzakmKnV00="
+    },
+    "kotlin-daemon-embeddable-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-daemon-embeddable/1.7.21/kotlin-daemon-embeddable-1.7.21.pom",
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-daemon-embeddable/1.7.21/kotlin-daemon-embeddable-1.7.21.pom"
+      ],
+      "hash": "sha256-vB3pwgh7ouTlQQF6i66PQF7IAKGK5MJH6R8rVedh5kk="
+    }
+  },
+  "org.jetbrains.intellij.deps:trove4j:1.0.20200330": {
+    "trove4j-1.0.20200330.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/intellij/deps/trove4j/1.0.20200330/trove4j-1.0.20200330.jar",
+        "https://repo.maven.apache.org/maven2/org/jetbrains/intellij/deps/trove4j/1.0.20200330/trove4j-1.0.20200330.jar"
+      ],
+      "hash": "sha256-xf1yW/+rUYRr88d9sTg8YKquv+G3/i8A0j/ht98KQ50="
+    },
+    "trove4j-1.0.20200330.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/intellij/deps/trove4j/1.0.20200330/trove4j-1.0.20200330.pom",
+        "https://repo.maven.apache.org/maven2/org/jetbrains/intellij/deps/trove4j/1.0.20200330/trove4j-1.0.20200330.pom"
+      ],
+      "hash": "sha256-h3IcuqZaPJfYsbqdIHhA8WTJ/jh1n8nqEP/iZWX40+k="
+    }
+  },
+  "net.java.dev.jna:jna:5.6.0": {
+    "jna-5.6.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/net/java/dev/jna/jna/5.6.0/jna-5.6.0.jar",
+        "https://repo.maven.apache.org/maven2/net/java/dev/jna/jna/5.6.0/jna-5.6.0.jar"
+      ],
+      "hash": "sha256-VVfiNaiqL5dm1dxgnWeUjyqIMsLXls6p7x1svgs7fq8="
+    },
+    "jna-5.6.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/net/java/dev/jna/jna/5.6.0/jna-5.6.0.pom",
+        "https://repo.maven.apache.org/maven2/net/java/dev/jna/jna/5.6.0/jna-5.6.0.pom"
+      ],
+      "hash": "sha256-X+gbAlWXjyRhbTexBgi3lJil8wc+HZsgONhzaoMfJgg="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-annotation-processing-gradle:1.7.21": {
+    "kotlin-annotation-processing-gradle-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-annotation-processing-gradle/1.7.21/kotlin-annotation-processing-gradle-1.7.21.jar"
+      ],
+      "hash": "sha256-RhyKdFvNVeRyXykBIVnUdOEor/G4KlPR80UkYFK5cwk="
+    },
+    "kotlin-annotation-processing-gradle-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-annotation-processing-gradle/1.7.21/kotlin-annotation-processing-gradle-1.7.21.pom"
+      ],
+      "hash": "sha256-r2JZxfjfTezw8FXmZcTLaP8TtK9c1HfuHTO/7gAaFr4="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-android-extensions:1.7.21": {
+    "kotlin-android-extensions-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-android-extensions/1.7.21/kotlin-android-extensions-1.7.21.jar"
+      ],
+      "hash": "sha256-JVeliP7QxmbRVq1uDfXjFOqz1p5m6aJyJ5uaRiQ0xq8="
+    },
+    "kotlin-android-extensions-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-android-extensions/1.7.21/kotlin-android-extensions-1.7.21.pom"
+      ],
+      "hash": "sha256-8pic3UN0A8hyZc/K8GHSFOaGlVyX40ntFWa6FqouDI0="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-compiler-runner:1.7.21": {
+    "kotlin-compiler-runner-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-compiler-runner/1.7.21/kotlin-compiler-runner-1.7.21.jar"
+      ],
+      "hash": "sha256-LdVae/7udr97ASbFtx0FuJmBK6a0Cjc1n50T+uIC8yc="
+    },
+    "kotlin-compiler-runner-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-compiler-runner/1.7.21/kotlin-compiler-runner-1.7.21.pom"
+      ],
+      "hash": "sha256-+JDieVykDuyu+jpdjkOND3C7YCo5SUe7rOp2Quqy+Tw="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-build-common:1.7.21": {
+    "kotlin-build-common-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-build-common/1.7.21/kotlin-build-common-1.7.21.jar"
+      ],
+      "hash": "sha256-Y3O9HhUPfcsnL1KvvBWZBkCSqddbKM7WvroA/qy6u/8="
+    },
+    "kotlin-build-common-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-build-common/1.7.21/kotlin-build-common-1.7.21.pom"
+      ],
+      "hash": "sha256-msmBVHbIUfFKH3QeG46CJRxyepVGgMdXT4owUn2z718="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-daemon-client:1.7.21": {
+    "kotlin-daemon-client-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-daemon-client/1.7.21/kotlin-daemon-client-1.7.21.jar"
+      ],
+      "hash": "sha256-tyPlHq8syE/a+sqHJnk/7I1SFyUNiAv0eDA/JE3UGoU="
+    },
+    "kotlin-daemon-client-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-daemon-client/1.7.21/kotlin-daemon-client-1.7.21.pom"
+      ],
+      "hash": "sha256-Be4Gj7v3IvWRSlqiWO6KKLZChF9B1/+bVGhtXKJbvxk="
+    }
+  },
+  "org.jetbrains.kotlinx:kotlinx-coroutines-core-jvm:1.5.0": {
+    "kotlinx-coroutines-core-jvm-1.5.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.5.0/kotlinx-coroutines-core-jvm-1.5.0.jar"
+      ],
+      "hash": "sha256-eNbMcTX4TWkv83Uvz9H6G74JQNffcGUuTx6u7Ax4r7s="
+    },
+    "kotlinx-coroutines-core-jvm-1.5.0.module": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.5.0/kotlinx-coroutines-core-jvm-1.5.0.module"
+      ],
+      "hash": "sha256-yIXdAoEHbFhDgm3jF+PLzcPYhZ2+71OuHPrNG5xg+W4="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-scripting-compiler-embeddable:1.7.21": {
+    "kotlin-scripting-compiler-embeddable-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-scripting-compiler-embeddable/1.7.21/kotlin-scripting-compiler-embeddable-1.7.21.jar",
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-scripting-compiler-embeddable/1.7.21/kotlin-scripting-compiler-embeddable-1.7.21.jar"
+      ],
+      "hash": "sha256-qu9jHwICEl2ZHZgjRxn4ZK1anW40m/DtRGsTd9gXGKE="
+    },
+    "kotlin-scripting-compiler-embeddable-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-scripting-compiler-embeddable/1.7.21/kotlin-scripting-compiler-embeddable-1.7.21.pom",
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-scripting-compiler-embeddable/1.7.21/kotlin-scripting-compiler-embeddable-1.7.21.pom"
+      ],
+      "hash": "sha256-xHXL2+0BepcMD9y46qu1UNc9E6T+a4e3efxM9S148JM="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-scripting-compiler-impl-embeddable:1.7.21": {
+    "kotlin-scripting-compiler-impl-embeddable-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-scripting-compiler-impl-embeddable/1.7.21/kotlin-scripting-compiler-impl-embeddable-1.7.21.jar",
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-scripting-compiler-impl-embeddable/1.7.21/kotlin-scripting-compiler-impl-embeddable-1.7.21.jar"
+      ],
+      "hash": "sha256-ZOK9uuvzgJSzwh5nCX5Qe4NoTaQTi6h6CwmhMgOXVCg="
+    },
+    "kotlin-scripting-compiler-impl-embeddable-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-scripting-compiler-impl-embeddable/1.7.21/kotlin-scripting-compiler-impl-embeddable-1.7.21.pom",
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-scripting-compiler-impl-embeddable/1.7.21/kotlin-scripting-compiler-impl-embeddable-1.7.21.pom"
+      ],
+      "hash": "sha256-5c0+HEj+qhC1YVqidOFh5/dcFijcJhZ1ALZ0b4gfweM="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-scripting-common:1.7.21": {
+    "kotlin-scripting-common-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-scripting-common/1.7.21/kotlin-scripting-common-1.7.21.jar",
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-scripting-common/1.7.21/kotlin-scripting-common-1.7.21.jar"
+      ],
+      "hash": "sha256-0ZLMLNlDFecijrkTZqNpdmpoIrPOvKwUwR1MSXM2y6Q="
+    },
+    "kotlin-scripting-common-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-scripting-common/1.7.21/kotlin-scripting-common-1.7.21.pom",
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-scripting-common/1.7.21/kotlin-scripting-common-1.7.21.pom"
+      ],
+      "hash": "sha256-2xzYRWGPDLQXOK3H72jZ+NIjZ1sFg+NbsMCEA30AWe4="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-scripting-jvm:1.7.21": {
+    "kotlin-scripting-jvm-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-scripting-jvm/1.7.21/kotlin-scripting-jvm-1.7.21.jar",
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-scripting-jvm/1.7.21/kotlin-scripting-jvm-1.7.21.jar"
+      ],
+      "hash": "sha256-Uz441a1oFCoFE0HyK8cO113IUGSxk3rPBRN1XMPwSF4="
+    },
+    "kotlin-scripting-jvm-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-scripting-jvm/1.7.21/kotlin-scripting-jvm-1.7.21.pom",
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-scripting-jvm/1.7.21/kotlin-scripting-jvm-1.7.21.pom"
+      ],
+      "hash": "sha256-cnwtOnluoiOWPu7P7kHvKygsVbZ+V8O0mgFwpMSbfGE="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.7.21": {
+    "kotlin-stdlib-jdk8-1.7.21.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.7.21/kotlin-stdlib-jdk8-1.7.21.jar"
+      ],
+      "hash": "sha256-sy5K5+uwVycz/kOThb8DT1+u6LbFhdQW/s+TPpSR044="
+    },
+    "kotlin-stdlib-jdk8-1.7.21.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.7.21/kotlin-stdlib-jdk8-1.7.21.pom"
+      ],
+      "hash": "sha256-bzuTQ8QS1q5ApMePuKcJhklkUKlSjNusdimojhqlg4k="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-stdlib:1.7.21": {
+    "kotlin-stdlib-1.7.21.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib/1.7.21/kotlin-stdlib-1.7.21.jar"
+      ],
+      "hash": "sha256-1Gqddz/7ne5P8adIrIRdyOUABcWJMClRdgorUYe93Rk="
+    },
+    "kotlin-stdlib-1.7.21.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib/1.7.21/kotlin-stdlib-1.7.21.pom"
+      ],
+      "hash": "sha256-mzkq1D4vQhJp9jxiBz+ulCN9LjHe7o9msZzBkbTaBqw="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-stdlib-common:1.7.21": {
+    "kotlin-stdlib-common-1.7.21.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib-common/1.7.21/kotlin-stdlib-common-1.7.21.jar"
+      ],
+      "hash": "sha256-5iv+yiNhA6EBciS4oiqEHbXcTbSdgKOb1E27IkaEpmo="
+    },
+    "kotlin-stdlib-common-1.7.21.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib-common/1.7.21/kotlin-stdlib-common-1.7.21.pom"
+      ],
+      "hash": "sha256-LuberkeOGLGvushzHFvxoUe1dWiT1Z7b+nEWBcNDX4Q="
+    }
+  },
+  "org.jetbrains:annotations:13.0": {
+    "annotations-13.0.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/annotations/13.0/annotations-13.0.jar"
+      ],
+      "hash": "sha256-rOKhDcji1f00kl7KwD5JiLLA+FFlDJS4zvSbob0RFHg="
+    },
+    "annotations-13.0.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/annotations/13.0/annotations-13.0.pom"
+      ],
+      "hash": "sha256-llrrK+3/NpgZvd4b96CzuJuCR91pyIuGN112Fju4w5c="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-stdlib-jdk7:1.7.21": {
+    "kotlin-stdlib-jdk7-1.7.21.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.7.21/kotlin-stdlib-jdk7-1.7.21.jar"
+      ],
+      "hash": "sha256-uMqg+XFaIYf0+pmQba5Xy6EM7vmn+Ajb7o6vNjWVWKU="
+    },
+    "kotlin-stdlib-jdk7-1.7.21.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.7.21/kotlin-stdlib-jdk7-1.7.21.pom"
+      ],
+      "hash": "sha256-vy6yU9onofKT0RRpMpRBeF26xRceWB8v7Z1aKm2YaZw="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-script-runtime:1.7.21": {
+    "kotlin-script-runtime-1.7.21.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-script-runtime/1.7.21/kotlin-script-runtime-1.7.21.jar"
+      ],
+      "hash": "sha256-LEmLbZiWTK3dS1hLe0mPmxCPaf8akVOrxlt02uQJJ/Y="
+    },
+    "kotlin-script-runtime-1.7.21.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-script-runtime/1.7.21/kotlin-script-runtime-1.7.21.pom"
+      ],
+      "hash": "sha256-LuSdd/3Dw6l0akiYCbfGQ3fh2NnEXCDZI+MXI5sicwQ="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-reflect:1.7.21": {
+    "kotlin-reflect-1.7.21.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-reflect/1.7.21/kotlin-reflect-1.7.21.jar"
+      ],
+      "hash": "sha256-wbF65MSTF+7Sb3ecM8lpBEbFZp6zx+Jsibbg1s8sogQ="
+    },
+    "kotlin-reflect-1.7.21.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-reflect/1.7.21/kotlin-reflect-1.7.21.pom"
+      ],
+      "hash": "sha256-Xn69/iAG9vHksPORwbqBhTmKj2NF2xpStYTx40Cz8EM="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-klib-commonizer-embeddable:1.7.21": {
+    "kotlin-klib-commonizer-embeddable-1.7.21.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-klib-commonizer-embeddable/1.7.21/kotlin-klib-commonizer-embeddable-1.7.21.jar"
+      ],
+      "hash": "sha256-nTpktCC+2+20HV5tsJ28h2FKffCBR5PACQqDYJBp+1Y="
+    },
+    "kotlin-klib-commonizer-embeddable-1.7.21.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-klib-commonizer-embeddable/1.7.21/kotlin-klib-commonizer-embeddable-1.7.21.pom"
+      ],
+      "hash": "sha256-bOmRoyzYOdq3wbf88+1xbr6XgbRgg3ViDC9fH8RwjrA="
+    }
+  }
+}

fixtures/golden/plugin/resolves-from-default-repo.kotlin.json

@@ -0,0 +1,494 @@
+{
+  "org.jetbrains.kotlin.jvm:org.jetbrains.kotlin.jvm.gradle.plugin:1.7.21": {
+    "org.jetbrains.kotlin.jvm.gradle.plugin-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/jvm/org.jetbrains.kotlin.jvm.gradle.plugin/1.7.21/org.jetbrains.kotlin.jvm.gradle.plugin-1.7.21.pom"
+      ],
+      "hash": "sha256-18S+c5nTziimR77ivh3nCwUdpLqoz9X4KYNDJ2UKD30="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-gradle-plugin:1.7.21": {
+    "kotlin-gradle-plugin-1.7.21-gradle71.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin/1.7.21/kotlin-gradle-plugin-1.7.21-gradle71.jar"
+      ],
+      "hash": "sha256-P12cqfSxiGOZjcVpNIk9m1ICRRzucJ+uuXbI+rI2cyI="
+    },
+    "kotlin-gradle-plugin-1.7.21.module": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin/1.7.21/kotlin-gradle-plugin-1.7.21.module"
+      ],
+      "hash": "sha256-j6I2KYtJBynes0XjG8ZPKSj3wbXxwjH8ZtvINlnBZ+E="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-gradle-plugin-api:1.7.21": {
+    "kotlin-gradle-plugin-api-1.7.21-gradle71.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin-api/1.7.21/kotlin-gradle-plugin-api-1.7.21-gradle71.jar"
+      ],
+      "hash": "sha256-rflytT2LY7s2jZA88y6bB+pTZW6PnaXxDfuv03gxviE="
+    },
+    "kotlin-gradle-plugin-api-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin-api/1.7.21/kotlin-gradle-plugin-api-1.7.21.jar"
+      ],
+      "hash": "sha256-rflytT2LY7s2jZA88y6bB+pTZW6PnaXxDfuv03gxviE="
+    },
+    "kotlin-gradle-plugin-api-1.7.21.module": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin-api/1.7.21/kotlin-gradle-plugin-api-1.7.21.module"
+      ],
+      "hash": "sha256-zGXnGhweng0JaG9cpJGORShIY1q7VCl15HwYlnw6A10="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-native-utils:1.7.21": {
+    "kotlin-native-utils-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-native-utils/1.7.21/kotlin-native-utils-1.7.21.jar"
+      ],
+      "hash": "sha256-k1KYF/2Nj9hlItZqqtyr0UKhcueMz+uUnNKJ40xw+Qs="
+    },
+    "kotlin-native-utils-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-native-utils/1.7.21/kotlin-native-utils-1.7.21.pom"
+      ],
+      "hash": "sha256-CEYFdUhagoAZC0g8H3fyCk063IegIXTzDuxVdNm65FY="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-util-io:1.7.21": {
+    "kotlin-util-io-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-util-io/1.7.21/kotlin-util-io-1.7.21.jar"
+      ],
+      "hash": "sha256-7MKI4AQqAUdgOeILbOXgaRj+8fic+J9V39KO8Xwm800="
+    },
+    "kotlin-util-io-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-util-io/1.7.21/kotlin-util-io-1.7.21.pom"
+      ],
+      "hash": "sha256-ziTM1kPWW+8Cey9uINCnkhdq29ug2eVVmS5CR6Y3Ne8="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-project-model:1.7.21": {
+    "kotlin-project-model-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-project-model/1.7.21/kotlin-project-model-1.7.21.jar"
+      ],
+      "hash": "sha256-4htTvrj3SxM6Y4mClPSlfcSiKJvoVfZrD5rosVYjFT8="
+    },
+    "kotlin-project-model-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-project-model/1.7.21/kotlin-project-model-1.7.21.pom"
+      ],
+      "hash": "sha256-JQfT7SKoHyssNSxMUOY1MivHEQClFQJN0NtQRifJ8Bs="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-tooling-core:1.7.21": {
+    "kotlin-tooling-core-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-tooling-core/1.7.21/kotlin-tooling-core-1.7.21.jar"
+      ],
+      "hash": "sha256-N5fxg1NC+8EuycHU+YMyugKCkaMyUakHySJ9j9lK7kg="
+    },
+    "kotlin-tooling-core-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-tooling-core/1.7.21/kotlin-tooling-core-1.7.21.pom"
+      ],
+      "hash": "sha256-tw2g1Eorhw7Lz85ZcMMOOOLs3htfQqHdRC0TA5gSKUY="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-gradle-plugin-model:1.7.21": {
+    "kotlin-gradle-plugin-model-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin-model/1.7.21/kotlin-gradle-plugin-model-1.7.21.jar"
+      ],
+      "hash": "sha256-FNP/F7o8tMi+uK3297QFB4gTS4kbsTyr5yPIwQ0dDhg="
+    },
+    "kotlin-gradle-plugin-model-1.7.21.module": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin-model/1.7.21/kotlin-gradle-plugin-model-1.7.21.module"
+      ],
+      "hash": "sha256-kCJoZCp1guVF4xgQnjdIw3WxOLCKFVuBX2yAi7vuR7U="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-gradle-plugin-idea:1.7.21": {
+    "kotlin-gradle-plugin-idea-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin-idea/1.7.21/kotlin-gradle-plugin-idea-1.7.21.jar"
+      ],
+      "hash": "sha256-C1dqyzeBqctWEKphxbev3zKQ/C2digzUv+FTe4dcReY="
+    },
+    "kotlin-gradle-plugin-idea-1.7.21.module": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin-idea/1.7.21/kotlin-gradle-plugin-idea-1.7.21.module"
+      ],
+      "hash": "sha256-ygHy2JJMcpaXMax+oVbwi7GP60LDEAClIj2dwW1ZuTg="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-gradle-plugin-idea-proto:1.7.21": {
+    "kotlin-gradle-plugin-idea-proto-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin-idea-proto/1.7.21/kotlin-gradle-plugin-idea-proto-1.7.21.jar"
+      ],
+      "hash": "sha256-NZhwZybLzo0oE05oiZw9WAv3LH6/kJcUHY28rtgnmHg="
+    },
+    "kotlin-gradle-plugin-idea-proto-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-gradle-plugin-idea-proto/1.7.21/kotlin-gradle-plugin-idea-proto-1.7.21.pom"
+      ],
+      "hash": "sha256-PRwDYK9odF8qAyoMAYR//Pnriq1wa/ZZydhAoYTsXyM="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-util-klib:1.7.21": {
+    "kotlin-util-klib-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-util-klib/1.7.21/kotlin-util-klib-1.7.21.jar"
+      ],
+      "hash": "sha256-UgkkU0RkIN+7h4BN6s6yGfVI53fm3xK35wRKOmaHEgs="
+    },
+    "kotlin-util-klib-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-util-klib/1.7.21/kotlin-util-klib-1.7.21.pom"
+      ],
+      "hash": "sha256-D8d7J3Rc+kzuX+AA5tEpmtSUT3rMB4A7u8ws0rAT3oU="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-klib-commonizer-api:1.7.21": {
+    "kotlin-klib-commonizer-api-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-klib-commonizer-api/1.7.21/kotlin-klib-commonizer-api-1.7.21.jar"
+      ],
+      "hash": "sha256-MOGWrbAAH9F7ZgNe2QcNPw5Hui0ycTt1wwPGt7e3FeI="
+    },
+    "kotlin-klib-commonizer-api-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-klib-commonizer-api/1.7.21/kotlin-klib-commonizer-api-1.7.21.pom"
+      ],
+      "hash": "sha256-so6g3vy5lNH7U6e7olh9J0DG0mAXk2UglP1ox0Ul0CA="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-compiler-embeddable:1.7.21": {
+    "kotlin-compiler-embeddable-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-compiler-embeddable/1.7.21/kotlin-compiler-embeddable-1.7.21.jar",
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-compiler-embeddable/1.7.21/kotlin-compiler-embeddable-1.7.21.jar"
+      ],
+      "hash": "sha256-Ty5JK8x5XgaA4/h67qGtrp8wbK9SBAuUpvoPiP2skvk="
+    },
+    "kotlin-compiler-embeddable-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-compiler-embeddable/1.7.21/kotlin-compiler-embeddable-1.7.21.pom",
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-compiler-embeddable/1.7.21/kotlin-compiler-embeddable-1.7.21.pom"
+      ],
+      "hash": "sha256-CwIzMip2MO/eEzUmjkYSPw1tNjg5gg/TfE7Lbv+njjs="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-daemon-embeddable:1.7.21": {
+    "kotlin-daemon-embeddable-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-daemon-embeddable/1.7.21/kotlin-daemon-embeddable-1.7.21.jar",
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-daemon-embeddable/1.7.21/kotlin-daemon-embeddable-1.7.21.jar"
+      ],
+      "hash": "sha256-A+bwJUNSJIlOSe5e2EfLCwtKh540z6uQ1wzakmKnV00="
+    },
+    "kotlin-daemon-embeddable-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-daemon-embeddable/1.7.21/kotlin-daemon-embeddable-1.7.21.pom",
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-daemon-embeddable/1.7.21/kotlin-daemon-embeddable-1.7.21.pom"
+      ],
+      "hash": "sha256-vB3pwgh7ouTlQQF6i66PQF7IAKGK5MJH6R8rVedh5kk="
+    }
+  },
+  "org.jetbrains.intellij.deps:trove4j:1.0.20200330": {
+    "trove4j-1.0.20200330.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/intellij/deps/trove4j/1.0.20200330/trove4j-1.0.20200330.jar",
+        "https://repo.maven.apache.org/maven2/org/jetbrains/intellij/deps/trove4j/1.0.20200330/trove4j-1.0.20200330.jar"
+      ],
+      "hash": "sha256-xf1yW/+rUYRr88d9sTg8YKquv+G3/i8A0j/ht98KQ50="
+    },
+    "trove4j-1.0.20200330.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/intellij/deps/trove4j/1.0.20200330/trove4j-1.0.20200330.pom",
+        "https://repo.maven.apache.org/maven2/org/jetbrains/intellij/deps/trove4j/1.0.20200330/trove4j-1.0.20200330.pom"
+      ],
+      "hash": "sha256-h3IcuqZaPJfYsbqdIHhA8WTJ/jh1n8nqEP/iZWX40+k="
+    }
+  },
+  "net.java.dev.jna:jna:5.6.0": {
+    "jna-5.6.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/net/java/dev/jna/jna/5.6.0/jna-5.6.0.jar",
+        "https://repo.maven.apache.org/maven2/net/java/dev/jna/jna/5.6.0/jna-5.6.0.jar"
+      ],
+      "hash": "sha256-VVfiNaiqL5dm1dxgnWeUjyqIMsLXls6p7x1svgs7fq8="
+    },
+    "jna-5.6.0.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/net/java/dev/jna/jna/5.6.0/jna-5.6.0.pom",
+        "https://repo.maven.apache.org/maven2/net/java/dev/jna/jna/5.6.0/jna-5.6.0.pom"
+      ],
+      "hash": "sha256-X+gbAlWXjyRhbTexBgi3lJil8wc+HZsgONhzaoMfJgg="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-annotation-processing-gradle:1.7.21": {
+    "kotlin-annotation-processing-gradle-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-annotation-processing-gradle/1.7.21/kotlin-annotation-processing-gradle-1.7.21.jar"
+      ],
+      "hash": "sha256-RhyKdFvNVeRyXykBIVnUdOEor/G4KlPR80UkYFK5cwk="
+    },
+    "kotlin-annotation-processing-gradle-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-annotation-processing-gradle/1.7.21/kotlin-annotation-processing-gradle-1.7.21.pom"
+      ],
+      "hash": "sha256-r2JZxfjfTezw8FXmZcTLaP8TtK9c1HfuHTO/7gAaFr4="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-android-extensions:1.7.21": {
+    "kotlin-android-extensions-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-android-extensions/1.7.21/kotlin-android-extensions-1.7.21.jar"
+      ],
+      "hash": "sha256-JVeliP7QxmbRVq1uDfXjFOqz1p5m6aJyJ5uaRiQ0xq8="
+    },
+    "kotlin-android-extensions-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-android-extensions/1.7.21/kotlin-android-extensions-1.7.21.pom"
+      ],
+      "hash": "sha256-8pic3UN0A8hyZc/K8GHSFOaGlVyX40ntFWa6FqouDI0="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-compiler-runner:1.7.21": {
+    "kotlin-compiler-runner-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-compiler-runner/1.7.21/kotlin-compiler-runner-1.7.21.jar"
+      ],
+      "hash": "sha256-LdVae/7udr97ASbFtx0FuJmBK6a0Cjc1n50T+uIC8yc="
+    },
+    "kotlin-compiler-runner-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-compiler-runner/1.7.21/kotlin-compiler-runner-1.7.21.pom"
+      ],
+      "hash": "sha256-+JDieVykDuyu+jpdjkOND3C7YCo5SUe7rOp2Quqy+Tw="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-build-common:1.7.21": {
+    "kotlin-build-common-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-build-common/1.7.21/kotlin-build-common-1.7.21.jar"
+      ],
+      "hash": "sha256-Y3O9HhUPfcsnL1KvvBWZBkCSqddbKM7WvroA/qy6u/8="
+    },
+    "kotlin-build-common-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-build-common/1.7.21/kotlin-build-common-1.7.21.pom"
+      ],
+      "hash": "sha256-msmBVHbIUfFKH3QeG46CJRxyepVGgMdXT4owUn2z718="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-daemon-client:1.7.21": {
+    "kotlin-daemon-client-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-daemon-client/1.7.21/kotlin-daemon-client-1.7.21.jar"
+      ],
+      "hash": "sha256-tyPlHq8syE/a+sqHJnk/7I1SFyUNiAv0eDA/JE3UGoU="
+    },
+    "kotlin-daemon-client-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-daemon-client/1.7.21/kotlin-daemon-client-1.7.21.pom"
+      ],
+      "hash": "sha256-Be4Gj7v3IvWRSlqiWO6KKLZChF9B1/+bVGhtXKJbvxk="
+    }
+  },
+  "org.jetbrains.kotlinx:kotlinx-coroutines-core-jvm:1.5.0": {
+    "kotlinx-coroutines-core-jvm-1.5.0.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.5.0/kotlinx-coroutines-core-jvm-1.5.0.jar"
+      ],
+      "hash": "sha256-eNbMcTX4TWkv83Uvz9H6G74JQNffcGUuTx6u7Ax4r7s="
+    },
+    "kotlinx-coroutines-core-jvm-1.5.0.module": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.5.0/kotlinx-coroutines-core-jvm-1.5.0.module"
+      ],
+      "hash": "sha256-yIXdAoEHbFhDgm3jF+PLzcPYhZ2+71OuHPrNG5xg+W4="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-scripting-compiler-embeddable:1.7.21": {
+    "kotlin-scripting-compiler-embeddable-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-scripting-compiler-embeddable/1.7.21/kotlin-scripting-compiler-embeddable-1.7.21.jar",
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-scripting-compiler-embeddable/1.7.21/kotlin-scripting-compiler-embeddable-1.7.21.jar"
+      ],
+      "hash": "sha256-qu9jHwICEl2ZHZgjRxn4ZK1anW40m/DtRGsTd9gXGKE="
+    },
+    "kotlin-scripting-compiler-embeddable-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-scripting-compiler-embeddable/1.7.21/kotlin-scripting-compiler-embeddable-1.7.21.pom",
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-scripting-compiler-embeddable/1.7.21/kotlin-scripting-compiler-embeddable-1.7.21.pom"
+      ],
+      "hash": "sha256-xHXL2+0BepcMD9y46qu1UNc9E6T+a4e3efxM9S148JM="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-scripting-compiler-impl-embeddable:1.7.21": {
+    "kotlin-scripting-compiler-impl-embeddable-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-scripting-compiler-impl-embeddable/1.7.21/kotlin-scripting-compiler-impl-embeddable-1.7.21.jar",
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-scripting-compiler-impl-embeddable/1.7.21/kotlin-scripting-compiler-impl-embeddable-1.7.21.jar"
+      ],
+      "hash": "sha256-ZOK9uuvzgJSzwh5nCX5Qe4NoTaQTi6h6CwmhMgOXVCg="
+    },
+    "kotlin-scripting-compiler-impl-embeddable-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-scripting-compiler-impl-embeddable/1.7.21/kotlin-scripting-compiler-impl-embeddable-1.7.21.pom",
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-scripting-compiler-impl-embeddable/1.7.21/kotlin-scripting-compiler-impl-embeddable-1.7.21.pom"
+      ],
+      "hash": "sha256-5c0+HEj+qhC1YVqidOFh5/dcFijcJhZ1ALZ0b4gfweM="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-scripting-common:1.7.21": {
+    "kotlin-scripting-common-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-scripting-common/1.7.21/kotlin-scripting-common-1.7.21.jar",
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-scripting-common/1.7.21/kotlin-scripting-common-1.7.21.jar"
+      ],
+      "hash": "sha256-0ZLMLNlDFecijrkTZqNpdmpoIrPOvKwUwR1MSXM2y6Q="
+    },
+    "kotlin-scripting-common-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-scripting-common/1.7.21/kotlin-scripting-common-1.7.21.pom",
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-scripting-common/1.7.21/kotlin-scripting-common-1.7.21.pom"
+      ],
+      "hash": "sha256-2xzYRWGPDLQXOK3H72jZ+NIjZ1sFg+NbsMCEA30AWe4="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-scripting-jvm:1.7.21": {
+    "kotlin-scripting-jvm-1.7.21.jar": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-scripting-jvm/1.7.21/kotlin-scripting-jvm-1.7.21.jar",
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-scripting-jvm/1.7.21/kotlin-scripting-jvm-1.7.21.jar"
+      ],
+      "hash": "sha256-Uz441a1oFCoFE0HyK8cO113IUGSxk3rPBRN1XMPwSF4="
+    },
+    "kotlin-scripting-jvm-1.7.21.pom": {
+      "urls": [
+        "https://plugins.gradle.org/m2/org/jetbrains/kotlin/kotlin-scripting-jvm/1.7.21/kotlin-scripting-jvm-1.7.21.pom",
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-scripting-jvm/1.7.21/kotlin-scripting-jvm-1.7.21.pom"
+      ],
+      "hash": "sha256-cnwtOnluoiOWPu7P7kHvKygsVbZ+V8O0mgFwpMSbfGE="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.7.21": {
+    "kotlin-stdlib-jdk8-1.7.21.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.7.21/kotlin-stdlib-jdk8-1.7.21.jar"
+      ],
+      "hash": "sha256-sy5K5+uwVycz/kOThb8DT1+u6LbFhdQW/s+TPpSR044="
+    },
+    "kotlin-stdlib-jdk8-1.7.21.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.7.21/kotlin-stdlib-jdk8-1.7.21.pom"
+      ],
+      "hash": "sha256-bzuTQ8QS1q5ApMePuKcJhklkUKlSjNusdimojhqlg4k="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-stdlib:1.7.21": {
+    "kotlin-stdlib-1.7.21.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib/1.7.21/kotlin-stdlib-1.7.21.jar"
+      ],
+      "hash": "sha256-1Gqddz/7ne5P8adIrIRdyOUABcWJMClRdgorUYe93Rk="
+    },
+    "kotlin-stdlib-1.7.21.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib/1.7.21/kotlin-stdlib-1.7.21.pom"
+      ],
+      "hash": "sha256-mzkq1D4vQhJp9jxiBz+ulCN9LjHe7o9msZzBkbTaBqw="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-stdlib-common:1.7.21": {
+    "kotlin-stdlib-common-1.7.21.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib-common/1.7.21/kotlin-stdlib-common-1.7.21.jar"
+      ],
+      "hash": "sha256-5iv+yiNhA6EBciS4oiqEHbXcTbSdgKOb1E27IkaEpmo="
+    },
+    "kotlin-stdlib-common-1.7.21.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib-common/1.7.21/kotlin-stdlib-common-1.7.21.pom"
+      ],
+      "hash": "sha256-LuberkeOGLGvushzHFvxoUe1dWiT1Z7b+nEWBcNDX4Q="
+    }
+  },
+  "org.jetbrains:annotations:13.0": {
+    "annotations-13.0.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/annotations/13.0/annotations-13.0.jar"
+      ],
+      "hash": "sha256-rOKhDcji1f00kl7KwD5JiLLA+FFlDJS4zvSbob0RFHg="
+    },
+    "annotations-13.0.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/annotations/13.0/annotations-13.0.pom"
+      ],
+      "hash": "sha256-llrrK+3/NpgZvd4b96CzuJuCR91pyIuGN112Fju4w5c="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-stdlib-jdk7:1.7.21": {
+    "kotlin-stdlib-jdk7-1.7.21.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.7.21/kotlin-stdlib-jdk7-1.7.21.jar"
+      ],
+      "hash": "sha256-uMqg+XFaIYf0+pmQba5Xy6EM7vmn+Ajb7o6vNjWVWKU="
+    },
+    "kotlin-stdlib-jdk7-1.7.21.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.7.21/kotlin-stdlib-jdk7-1.7.21.pom"
+      ],
+      "hash": "sha256-vy6yU9onofKT0RRpMpRBeF26xRceWB8v7Z1aKm2YaZw="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-script-runtime:1.7.21": {
+    "kotlin-script-runtime-1.7.21.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-script-runtime/1.7.21/kotlin-script-runtime-1.7.21.jar"
+      ],
+      "hash": "sha256-LEmLbZiWTK3dS1hLe0mPmxCPaf8akVOrxlt02uQJJ/Y="
+    },
+    "kotlin-script-runtime-1.7.21.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-script-runtime/1.7.21/kotlin-script-runtime-1.7.21.pom"
+      ],
+      "hash": "sha256-LuSdd/3Dw6l0akiYCbfGQ3fh2NnEXCDZI+MXI5sicwQ="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-reflect:1.7.21": {
+    "kotlin-reflect-1.7.21.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-reflect/1.7.21/kotlin-reflect-1.7.21.jar"
+      ],
+      "hash": "sha256-wbF65MSTF+7Sb3ecM8lpBEbFZp6zx+Jsibbg1s8sogQ="
+    },
+    "kotlin-reflect-1.7.21.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-reflect/1.7.21/kotlin-reflect-1.7.21.pom"
+      ],
+      "hash": "sha256-Xn69/iAG9vHksPORwbqBhTmKj2NF2xpStYTx40Cz8EM="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-klib-commonizer-embeddable:1.7.21": {
+    "kotlin-klib-commonizer-embeddable-1.7.21.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-klib-commonizer-embeddable/1.7.21/kotlin-klib-commonizer-embeddable-1.7.21.jar"
+      ],
+      "hash": "sha256-nTpktCC+2+20HV5tsJ28h2FKffCBR5PACQqDYJBp+1Y="
+    },
+    "kotlin-klib-commonizer-embeddable-1.7.21.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-klib-commonizer-embeddable/1.7.21/kotlin-klib-commonizer-embeddable-1.7.21.pom"
+      ],
+      "hash": "sha256-bOmRoyzYOdq3wbf88+1xbr6XgbRgg3ViDC9fH8RwjrA="
+    }
+  }
+}

fixtures/golden/s3/maven-snapshot.groovy.json

@@ -0,0 +1,2 @@
+{
+}

fixtures/golden/s3/maven-snapshot.kotlin.json

@@ -0,0 +1,2 @@
+{
+}

fixtures/golden/s3/maven.groovy.json

@@ -0,0 +1,2 @@
+{
+}

fixtures/golden/s3/maven.kotlin.json

@@ -0,0 +1,2 @@
+{
+}

fixtures/golden/settings/buildscript.groovy.json

@@ -0,0 +1,16 @@
+{
+  "org.apache:test:1.0.0": {
+    "test-1.0.0.jar": {
+      "urls": [
+        "file:/home/tad/proj/gradle2nix/fixtures/repositories/m2/org/apache/test/1.0.0/test-1.0.0.jar"
+      ],
+      "hash": "sha256-M95zEuAwVCam7c2rKIET5qs4Q60sA84RyTA3a9jdQd8="
+    },
+    "test-1.0.0.pom": {
+      "urls": [
+        "file:/home/tad/proj/gradle2nix/fixtures/repositories/m2/org/apache/test/1.0.0/test-1.0.0.pom"
+      ],
+      "hash": "sha256-sYk8m4+T+hRJ+43tpPkthrE/JftrsMnmuzORCLCK1To="
+    }
+  }
+}

fixtures/golden/settings/dependency-resolution-management.kotlin.json

@@ -0,0 +1,16 @@
+{
+  "org.apache:test:1.0.0": {
+    "test-1.0.0.jar": {
+      "urls": [
+        "file:/home/tad/proj/gradle2nix/fixtures/repositories/m2/org/apache/test/1.0.0/test-1.0.0.jar"
+      ],
+      "hash": "sha256-M95zEuAwVCam7c2rKIET5qs4Q60sA84RyTA3a9jdQd8="
+    },
+    "test-1.0.0.pom": {
+      "urls": [
+        "file:/home/tad/proj/gradle2nix/fixtures/repositories/m2/org/apache/test/1.0.0/test-1.0.0.pom"
+      ],
+      "hash": "sha256-sYk8m4+T+hRJ+43tpPkthrE/JftrsMnmuzORCLCK1To="
+    }
+  }
+}

fixtures/golden/subprojects/multi-module.groovy.json

@@ -0,0 +1,114 @@
+{
+  "junit:junit:4.12": {
+    "junit-4.12.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/junit/junit/4.12/junit-4.12.jar"
+      ],
+      "hash": "sha256-WXIfCAXiI9hLkGd4h9n/Vn3FNNfFAsqQPAwrF/BcEWo="
+    },
+    "junit-4.12.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/junit/junit/4.12/junit-4.12.pom"
+      ],
+      "hash": "sha256-kPFj944/+28cetl96efrpO6iWAcUG4XW0SvmfKJUScQ="
+    }
+  },
+  "org.hamcrest:hamcrest-core:1.3": {
+    "hamcrest-core-1.3.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/hamcrest/hamcrest-core/1.3/hamcrest-core-1.3.jar"
+      ],
+      "hash": "sha256-Zv3vkelzk0jfeglqo4SlaF9Oh1WEzOiThqekclHE2Ok="
+    },
+    "hamcrest-core-1.3.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/hamcrest/hamcrest-core/1.3/hamcrest-core-1.3.pom"
+      ],
+      "hash": "sha256-/eOGp5BRc6GxA95quCBydYS1DQ4yKC4nl3h8IKZP+pM="
+    }
+  },
+  "com.squareup.okio:okio:2.2.2": {
+    "okio-2.2.2.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/com/squareup/okio/okio/2.2.2/okio-2.2.2.jar"
+      ],
+      "hash": "sha256-5YyXQGprsROIk3UCmaxjxqoEs4trSerhv8rRpj75uhs="
+    },
+    "okio-2.2.2.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/com/squareup/okio/okio/2.2.2/okio-2.2.2.pom"
+      ],
+      "hash": "sha256-/WIZiPf2lXAlc13G3QkLAKIPOju413ynkDYHf2KbFAs="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-stdlib:1.2.60": {
+    "kotlin-stdlib-1.2.60.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib/1.2.60/kotlin-stdlib-1.2.60.jar"
+      ],
+      "hash": "sha256-ahMCmPUXGsUqHiSW9+rnhbb1ZBbqPMuZ5DRNBNg/8HE="
+    },
+    "kotlin-stdlib-1.2.60.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib/1.2.60/kotlin-stdlib-1.2.60.pom"
+      ],
+      "hash": "sha256-5jKJkgnmtMqrlA/YLk7GOjLjJkP4Fff6cJdkeJDXnxg="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-stdlib-common:1.2.60": {
+    "kotlin-stdlib-common-1.2.60.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib-common/1.2.60/kotlin-stdlib-common-1.2.60.jar"
+      ],
+      "hash": "sha256-CbQ3WgZc8SeryZjF3PIrFmTEWvQrSJSZ16j0+Kt5P7E="
+    },
+    "kotlin-stdlib-common-1.2.60.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib-common/1.2.60/kotlin-stdlib-common-1.2.60.pom"
+      ],
+      "hash": "sha256-gwwnrx4c8k8PUm6kV5AcQ/OMGbtvfl03Y8PSU98bjaE="
+    }
+  },
+  "org.jetbrains:annotations:13.0": {
+    "annotations-13.0.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/annotations/13.0/annotations-13.0.jar"
+      ],
+      "hash": "sha256-rOKhDcji1f00kl7KwD5JiLLA+FFlDJS4zvSbob0RFHg="
+    },
+    "annotations-13.0.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/annotations/13.0/annotations-13.0.pom"
+      ],
+      "hash": "sha256-llrrK+3/NpgZvd4b96CzuJuCR91pyIuGN112Fju4w5c="
+    }
+  },
+  "com.squareup.moshi:moshi:1.8.0": {
+    "moshi-1.8.0.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/com/squareup/moshi/moshi/1.8.0/moshi-1.8.0.jar"
+      ],
+      "hash": "sha256-Qv50bSaU6hH+agK+zZ2iyj2v6Xye/VCg+a9cRZbnSmo="
+    },
+    "moshi-1.8.0.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/com/squareup/moshi/moshi/1.8.0/moshi-1.8.0.pom"
+      ],
+      "hash": "sha256-FLuAWbnddiACWSkN+IfjfmaaB0qsnImUAePIEC/lII8="
+    }
+  },
+  "com.squareup.okio:okio:1.16.0": {
+    "okio-1.16.0.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/com/squareup/okio/okio/1.16.0/okio-1.16.0.jar"
+      ],
+      "hash": "sha256-7ASE/xkDZA44RcKxCruZ7/LTIwj/40WeX5IwmkUbnH4="
+    },
+    "okio-1.16.0.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/com/squareup/okio/okio/1.16.0/okio-1.16.0.pom"
+      ],
+      "hash": "sha256-HSUhYhwIdRI6qRMRsv6O3v0O2T9mvm3+oYzGG8XJnjY="
+    }
+  }
+}

fixtures/golden/subprojects/multi-module.kotlin.json

@@ -0,0 +1,114 @@
+{
+  "junit:junit:4.12": {
+    "junit-4.12.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/junit/junit/4.12/junit-4.12.jar"
+      ],
+      "hash": "sha256-WXIfCAXiI9hLkGd4h9n/Vn3FNNfFAsqQPAwrF/BcEWo="
+    },
+    "junit-4.12.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/junit/junit/4.12/junit-4.12.pom"
+      ],
+      "hash": "sha256-kPFj944/+28cetl96efrpO6iWAcUG4XW0SvmfKJUScQ="
+    }
+  },
+  "org.hamcrest:hamcrest-core:1.3": {
+    "hamcrest-core-1.3.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/hamcrest/hamcrest-core/1.3/hamcrest-core-1.3.jar"
+      ],
+      "hash": "sha256-Zv3vkelzk0jfeglqo4SlaF9Oh1WEzOiThqekclHE2Ok="
+    },
+    "hamcrest-core-1.3.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/hamcrest/hamcrest-core/1.3/hamcrest-core-1.3.pom"
+      ],
+      "hash": "sha256-/eOGp5BRc6GxA95quCBydYS1DQ4yKC4nl3h8IKZP+pM="
+    }
+  },
+  "com.squareup.okio:okio:2.2.2": {
+    "okio-2.2.2.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/com/squareup/okio/okio/2.2.2/okio-2.2.2.jar"
+      ],
+      "hash": "sha256-5YyXQGprsROIk3UCmaxjxqoEs4trSerhv8rRpj75uhs="
+    },
+    "okio-2.2.2.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/com/squareup/okio/okio/2.2.2/okio-2.2.2.pom"
+      ],
+      "hash": "sha256-/WIZiPf2lXAlc13G3QkLAKIPOju413ynkDYHf2KbFAs="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-stdlib:1.2.60": {
+    "kotlin-stdlib-1.2.60.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib/1.2.60/kotlin-stdlib-1.2.60.jar"
+      ],
+      "hash": "sha256-ahMCmPUXGsUqHiSW9+rnhbb1ZBbqPMuZ5DRNBNg/8HE="
+    },
+    "kotlin-stdlib-1.2.60.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib/1.2.60/kotlin-stdlib-1.2.60.pom"
+      ],
+      "hash": "sha256-5jKJkgnmtMqrlA/YLk7GOjLjJkP4Fff6cJdkeJDXnxg="
+    }
+  },
+  "org.jetbrains.kotlin:kotlin-stdlib-common:1.2.60": {
+    "kotlin-stdlib-common-1.2.60.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib-common/1.2.60/kotlin-stdlib-common-1.2.60.jar"
+      ],
+      "hash": "sha256-CbQ3WgZc8SeryZjF3PIrFmTEWvQrSJSZ16j0+Kt5P7E="
+    },
+    "kotlin-stdlib-common-1.2.60.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/kotlin/kotlin-stdlib-common/1.2.60/kotlin-stdlib-common-1.2.60.pom"
+      ],
+      "hash": "sha256-gwwnrx4c8k8PUm6kV5AcQ/OMGbtvfl03Y8PSU98bjaE="
+    }
+  },
+  "org.jetbrains:annotations:13.0": {
+    "annotations-13.0.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/annotations/13.0/annotations-13.0.jar"
+      ],
+      "hash": "sha256-rOKhDcji1f00kl7KwD5JiLLA+FFlDJS4zvSbob0RFHg="
+    },
+    "annotations-13.0.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/org/jetbrains/annotations/13.0/annotations-13.0.pom"
+      ],
+      "hash": "sha256-llrrK+3/NpgZvd4b96CzuJuCR91pyIuGN112Fju4w5c="
+    }
+  },
+  "com.squareup.moshi:moshi:1.8.0": {
+    "moshi-1.8.0.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/com/squareup/moshi/moshi/1.8.0/moshi-1.8.0.jar"
+      ],
+      "hash": "sha256-Qv50bSaU6hH+agK+zZ2iyj2v6Xye/VCg+a9cRZbnSmo="
+    },
+    "moshi-1.8.0.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/com/squareup/moshi/moshi/1.8.0/moshi-1.8.0.pom"
+      ],
+      "hash": "sha256-FLuAWbnddiACWSkN+IfjfmaaB0qsnImUAePIEC/lII8="
+    }
+  },
+  "com.squareup.okio:okio:1.16.0": {
+    "okio-1.16.0.jar": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/com/squareup/okio/okio/1.16.0/okio-1.16.0.jar"
+      ],
+      "hash": "sha256-7ASE/xkDZA44RcKxCruZ7/LTIwj/40WeX5IwmkUbnH4="
+    },
+    "okio-1.16.0.pom": {
+      "urls": [
+        "https://repo.maven.apache.org/maven2/com/squareup/okio/okio/1.16.0/okio-1.16.0.pom"
+      ],
+      "hash": "sha256-HSUhYhwIdRI6qRMRsv6O3v0O2T9mvm3+oYzGG8XJnjY="
+    }
+  }
+}

fixtures/ivy/basic/kotlin/build.gradle.kts

@@ -5,10 +5,10 @@ plugins {
 repositories {
     ivy {
         url = uri("https://asset.opendof.org")
-        layout("pattern") {
+        patternLayout {
-            this as IvyPatternRepositoryLayout
             ivy("ivy2/[organisation]/[module]/[revision]/ivy(.[platform]).xml")
             artifact("artifact/[organisation]/[module]/[revision](/[platform])(/[type]s)/[artifact]-[revision](-[classifier]).[ext]")
+
         }
     }
 }

fixtures/plugin/resolves-from-default-repo/groovy/build.gradle

@@ -1,7 +1,7 @@
 plugins {
-    id "org.jetbrains.kotlin.jvm" version "1.3.50"
+    id "org.jetbrains.kotlin.jvm" version "1.7.21"
 }
 
 repositories {
-    jcenter()
+    mavenCentral()
 }

fixtures/plugin/resolves-from-default-repo/kotlin/build.gradle.kts

@@ -1,7 +1,8 @@
+
 plugins {
-    kotlin("jvm") version "1.3.50"
+    kotlin("jvm") version "1.7.21"
 }
 
 repositories {
-    jcenter()
+    mavenCentral()
 }

fixtures/s3/maven-snapshot/kotlin/build.gradle.kts

@@ -1,3 +1,4 @@
+
 plugins {
     java
 }

fixtures/settings/buildscript/groovy/settings.gradle

@@ -1,7 +1,7 @@
 buildscript {
     repositories {
         maven {
-            url 'http://localhost:9999/'
+            url System.getProperty("org.nixos.gradle2nix.m2")
         }
     }
     dependencies {

fixtures/settings/dependency-resolution-management/kotlin/build.gradle.kts

@@ -1,3 +1,4 @@
+
 plugins {
     java
 }

fixtures/settings/dependency-resolution-management/kotlin/settings.gradle.kts

@@ -1,6 +1,6 @@
 dependencyResolutionManagement {
     repositories {
-        maven { url = uri("http://localhost:9999") }
+        maven { url = uri(System.getProperty("org.nixos.gradle2nix.m2")) }
     }
     repositoriesMode.set(RepositoriesMode.PREFER_SETTINGS)
 }

fixtures/subprojects/dependent-subprojects/groovy/build.gradle

@@ -1,15 +0,0 @@
-subprojects {
-    apply plugin: 'java'
-}
-
-project(':child-a') {
-    dependencies {
-        implementation project(':child-b')
-    }
-}
-
-project(':child-b') {
-    dependencies {
-        implementation project(':child-c')
-    }
-}

fixtures/subprojects/dependent-subprojects/groovy/settings.gradle

@@ -1 +0,0 @@
-include ':child-a', ':child-b', ':child-c', ':child-d'

fixtures/subprojects/multi-module/groovy/build.gradle

@@ -4,7 +4,7 @@ plugins {
 
 allprojects {
     repositories {
-        jcenter()
+        mavenCentral()
     }
 }
 

fixtures/subprojects/multi-module/kotlin/build.gradle.kts

@@ -4,7 +4,7 @@ plugins {
 
 allprojects {
     repositories {
-        jcenter()
+        mavenCentral()
     }
 }
 

fixtures/subprojects/multi-module/kotlin/child-a/build.gradle.kts

@@ -1,3 +1,4 @@
+
 plugins {
     java
 }

fixtures/subprojects/multi-module/kotlin/child-b/build.gradle.kts

@@ -1,3 +1,4 @@
+
 plugins {
     java
 }

gradle.properties

@@ -1,6 +1,5 @@
 org.gradle.jvmargs='-Dfile.encoding=UTF-8'
+org.gradle.caching=true
+org.gradle.configuration-cache=true
 
 VERSION=1.0.0-rc2
-
-shadowVersion=6.1.0
-stutterVersion=0.6.0

gradle/libs.versions.toml

@@ -0,0 +1,43 @@
+[versions]
+gradle = "8.3"
+kotlin = "1.9.0" # Current embedded Gradle kotlin version
+ksp = "1.9.0-1.0.13"
+
+[libraries]
+clikt = "com.github.ajalt:clikt:+"
+gradle-dependencyGraph = "org.gradle:github-dependency-graph-gradle-plugin:+"
+gradle-toolingApi = { module = "org.gradle:gradle-tooling-api", version.ref = "gradle" }
+ivy = "org.apache.ivy:ivy:+"
+javalin = "io.javalin:javalin:+"
+junit-jupiter-api = "org.junit.jupiter:junit-jupiter-api:+"
+junit-jupiter-engine = "org.junit.jupiter:junit-jupiter-engine:+"
+junit-jupiter-params = "org.junit.jupiter:junit-jupiter-params:+"
+junit-platformLauncher = "org.junit.platform:junit-platform-launcher:+"
+kotest-runner = "io.kotest:kotest-runner-junit5:+"
+kotest-assertions = "io.kotest:kotest-assertions-core:+"
+maven-repositoryMetadata = "org.apache.maven:maven-repository-metadata:+"
+minutest = "dev.minutest:minutest:+"
+moshi = "com.squareup.moshi:moshi:+"
+moshi-adapters = "com.squareup.moshi:moshi-adapters:+"
+moshi-kotlin = "com.squareup.moshi:moshi-kotlin:+"
+moshi-kotlinCodegen = "com.squareup.moshi:moshi-kotlin-codegen:+"
+okio = "com.squareup.okio:okio:+"
+s3 = "com.amazonaws:aws-java-sdk-s3:+"
+s3mock = "com.adobe.testing:s3mock-junit5:+"
+semver = "net.swiftzer.semver:semver:+"
+serialization-json = "org.jetbrains.kotlinx:kotlinx-serialization-json:+"
+slf4j-api = "org.slf4j:slf4j-api:+"
+slf4j-simple = "org.slf4j:slf4j-simple:+"
+spek-dsl = "org.spekframework.spek2:spek-dsl-jvm:+"
+spek-runner = "org.spekframework.spek2:spek-runner-junit5:+"
+strikt = "io.strikt:strikt-core:+"
+
+[plugins]
+pluginPublish = { id = "com.gradle.plugin-publish", version = "1.2.1" }
+kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
+kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
+ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }
+shadow = { id = "com.github.johnrengelman.shadow", version = "8.1.1" }
+stutter = { id = "org.ajoberstar.stutter", version = "0.7.2" }
+
+[bundles]

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.8.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.3-all.zip
+networkTimeout=10000
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradlew

@@ -1,7 +1,7 @@
-#!/usr/bin/env sh
+#!/bin/sh
 
 #
-# Copyright 2015 the original author or authors.
+# Copyright © 2015-2021 the original authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -17,67 +17,101 @@
 #
 
 ##############################################################################
-##
+#
-##  Gradle start up script for UN*X
+#   Gradle start up script for POSIX generated by Gradle.
-##
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
 ##############################################################################
 
 # Attempt to set APP_HOME
-# Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
-done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
 
-APP_NAME="Gradle"
+# Resolve links: $0 may be a link
-APP_BASE_NAME=`basename "$0"`
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
 
 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
+MAX_FD=maximum
 
 warn () {
     echo "$*"
-}
+} >&2
 
 die () {
     echo
     echo "$*"
     echo
     exit 1
-}
+} >&2
 
 # OS specific support (must be 'true' or 'false').
 cygwin=false
 msys=false
 darwin=false
 nonstop=false
-case "`uname`" in
+case "$( uname )" in                #(
-  CYGWIN* )
+  CYGWIN* )         cygwin=true  ;; #(
-    cygwin=true
+  Darwin* )         darwin=true  ;; #(
-    ;;
+  MSYS* | MINGW* )  msys=true    ;; #(
-  Darwin* )
+  NONSTOP* )        nonstop=true ;;
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
 esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
@@ -87,9 +121,9 @@ CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
         # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
+        JAVACMD=$JAVA_HOME/jre/sh/java
     else
-        JAVACMD="$JAVA_HOME/bin/java"
+        JAVACMD=$JAVA_HOME/bin/java
     fi
     if [ ! -x "$JAVACMD" ] ; then
         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
@@ -98,7 +132,7 @@ Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
     fi
 else
-    JAVACMD="java"
+    JAVACMD=java
     which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
@@ -106,80 +140,105 @@ location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
+    case $MAX_FD in #(
-    if [ $? -eq 0 ] ; then
+      max*)
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
-            MAX_FD="$MAX_FD_LIMIT"
+        # shellcheck disable=SC3045 
-        fi
+        MAX_FD=$( ulimit -H -n ) ||
-        ulimit -n $MAX_FD
+            warn "Could not query maximum file descriptor limit"
-        if [ $? -ne 0 ] ; then
+    esac
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
+    case $MAX_FD in  #(
-        fi
+      '' | soft) :;; #(
-    else
+      *)
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
-    fi
+        # shellcheck disable=SC3045 
-fi
+        ulimit -n "$MAX_FD" ||
-
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=`expr $i + 1`
-    done
-    case $i in
-        0) set -- ;;
-        1) set -- "$args0" ;;
-        2) set -- "$args0" "$args1" ;;
-        3) set -- "$args0" "$args1" "$args2" ;;
-        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
     esac
 fi
 
-# Escape application args
+# Collect all arguments for the java command, stacking in reverse order:
-save () {
+#   * args from the command line
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+#   * the main class name
-    echo " "
+#   * -classpath
-}
+#   * -D...appname settings
-APP_ARGS=`save "$@"`
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
 
-# Collect all arguments for the java command, following the shell quoting and substitution rules
+# For Cygwin or MSYS, switch paths to Windows format before running java
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
 
 exec "$JAVACMD" "$@"

gradlew.bat

@@ -14,7 +14,7 @@
 @rem limitations under the License.
 @rem
 
-@if "%DEBUG%" == "" @echo off
+@if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
 @rem
 @rem  Gradle startup script for Windows
@@ -25,7 +25,8 @@
 if "%OS%"=="Windows_NT" setlocal
 
 set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
@@ -40,7 +41,7 @@ if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto execute
+if %ERRORLEVEL% equ 0 goto execute
 
 echo.
 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
@@ -75,13 +76,15 @@ set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
 :end
 @rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
+if %ERRORLEVEL% equ 0 goto mainEnd
 
 :fail
 rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
 rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+set EXIT_CODE=%ERRORLEVEL%
-exit /b 1
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
 
 :mainEnd
 if "%OS%"=="Windows_NT" endlocal