build.gradle

import groovy.json.JsonOutput
import groovy.json.JsonSlurper
import org.jetbrains.kotlin.gradle.dsl.KotlinVersion

plugins {
  alias(libs.plugins.kotlin.jvm)
  alias(libs.plugins.kotlin.serialization)
  alias(libs.plugins.android.lint)
  id("java-gradle-plugin")
  alias(libs.plugins.publish)
  alias(libs.plugins.dokka)
  alias(libs.plugins.spotless)
}

gradlePlugin {
  plugins {
    licensee {
      id = "app.cash.licensee"
      displayName = "Licensee"
      description = "Gradle plugin which validates the licenses of your dependency graph match what you expect"
      implementationClass = "app.cash.licensee.LicenseePlugin"
    }
  }
}

tasks.named("validatePlugins") {
  enableStricterValidation = true
}

dependencies {
  compileOnly libs.androidGradleApi
  compileOnly libs.kotlinGradlePlugin
  implementation libs.kotlinx.serialization
  implementation libs.maven.modelBuilder

  testImplementation libs.junit
  testImplementation libs.assertk
  testImplementation libs.testParameterInjector
  testImplementation gradleTestKit()

  lintChecks libs.androidx.gradlePluginLints
}

kotlin {
  jvmToolchain(11)
  target {
    compilations.configureEach {
      // Ensure compatibility with old Gradle versions. Keep in sync with LicenseePlugin.kt.
      compilerOptions.options.apiVersion.set(KotlinVersion.KOTLIN_1_8)
    }
  }
}

tasks.named("test") {
  dependsOn(':publishAllPublicationsToTestingRepository')
  systemProperty('licenseeVersion', VERSION_NAME)
  systemProperty('generatedSpdxFile', file("build/generated/spdx/app/cash/licensee/licensesSpdx.kt").path)
  systemProperty('line.separator', '\n')

  testLogging {
    if (System.getenv("CI") == "true") {
      events = ["failed", "skipped", "passed"]
    }
    exceptionFormat "full"
  }
  // AGP 8+ requires JVM 17+.
  javaLauncher = javaToolchains.launcherFor {
    languageVersion = JavaLanguageVersion.of(20)
  }

  // Required to test configuration cache in tests when using withDebug()
  // https://github.com/gradle/gradle/issues/22765#issuecomment-1339427241
  jvmArgs(
    "--add-opens",
    "java.base/java.util=ALL-UNNAMED",
    "--add-opens",
    "java.base/java.util.concurrent.atomic=ALL-UNNAMED",
    "--add-opens",
    "java.base/java.lang.invoke=ALL-UNNAMED",
    "--add-opens",
    "java.base/java.net=ALL-UNNAMED",
  )
}

def fixtures = file('src/test/fixtures')
def minimalJarBase64 = 'UEsFBgAAAAAAAAAAAAAAAAAAAAAAAA=='
tasks.register('writeFixtureJars') { task ->
  task.doFirst {
    fixtures.eachFileRecurse { File file ->
      if (file.toString().contains('/repo/') && file.name.endsWith('.jar')) {
        file.bytes = minimalJarBase64.decodeBase64()
      }
    }
  }
}
def checkFixtureJars = tasks.register('checkFixtureJars') { task ->
  task.doFirst {
    fixtures.eachFileRecurse { File file ->
      if (file.toString().contains('/repo/') && file.name.endsWith('.jar')) {
        def fileBase64 = file.readBytes().encodeBase64().toString()
        if (fileBase64 != minimalJarBase64) {
          throw new RuntimeException(
            "Expected '$minimalJarBase64' but was '$fileBase64'\n\n" +
              "Invoke 'writeFixtureJars' task to fix.")
        }
      }
    }
  }
}

tasks.named('check') { check ->
  check.dependsOn(checkFixtureJars)
}

Directory jsonFolder = layout.projectDirectory.dir("src/main/resources/app/cash/licensee")
RegularFile jsonFile = jsonFolder.file("licenses.json")

tasks.register("downloadLicensesJson", Copy) {
  group = "generatespdx"

  from(resources.text.fromUri("https://spdx.org/licenses/licenses.json").asFile()) {
    rename {
      jsonFile.asFile.name
    }
  }
  into(jsonFolder)

  doLast {
    def destFile = jsonFile.asFile
    def json = new JsonSlurper().parse(destFile)
    json.licenses = json.licenses.sort { a, b -> a.licenseId <=> b.licenseId }
    destFile.text = JsonOutput.prettyPrint(JsonOutput.toJson(json))
  }
}

TaskProvider<app.cash.licensee.GenerateSpdxIdTask> generateSpdx = tasks.register('generateSpdx', app.cash.licensee.GenerateSpdxIdTask) {
  // Do not wire the output from writeSortedSpdx here to split downloading the remote file and code gen.
  inputJson.set(jsonFile)
}

sourceSets.main.kotlin.srcDir(generateSpdx)

publishing {
  repositories {
    maven {
      name = "testing"
      url = "${rootProject.projectDir}/build/localMaven"
    }
  }
}

spotless {
  kotlin {
    target('**/*.kt')
    targetExclude("**/src/test/test-build-logic/build/**", "**/generated-sources/**")
    ktlint(libs.ktlint.get().version).editorConfigOverride([
      'ktlint_standard_filename': 'disabled',
      // Making something an expression body should be a choice around readability.
      'ktlint_standard_function-expression-body': 'disabled',
    ])
    licenseHeaderFile(rootProject.file('gradle/license-header.txt'))
  }
}