build.gradle

plugins {
  id "java"
  id "maven-publish"
  id "signing"
  id 'com.github.gmazzo.buildconfig' version "5.3.5"
  id 'com.nwalsh.gradle.saxon.saxon-gradle' version '0.9.6'
  id 'com.nwalsh.gradle.docker.container' version '0.0.5'
}

compileJava {
  sourceCompatibility = 1.8
  targetCompatibility = 1.8
  options.compilerArgs << "-Xlint:deprecation" << "-Xlint:-options"
}

repositories {
  mavenLocal()
  mavenCentral()
  maven { url "https://maven.saxonica.com/maven" }
}

java {
  toolchain {
    languageVersion.set(JavaLanguageVersion.of(21))
  }
  registerFeature('validating') {
    usingSourceSet(sourceSets["main"])
  }
}

configurations.all {
  resolutionStrategy {
    exclude group: 'xml-apis', module: 'xml-apis'
  }
}

configurations {
  standaloneClasspath.extendsFrom(implementation)
  docletConfiguration.extendsFrom(docletImplementation)
}

dependencies {
  validatingImplementation (
    [group: 'org.relaxng', name: 'jing', version: '20220510' ]
  )

  docletImplementation (
    [group: 'org.relaxng', name: 'jing', version: '20220510' ],
    [group: 'com.saxonica', name: 'xmldoclet', version: '0.4.0']
  )

  testImplementation (
    [group: 'org.junit.jupiter', name: 'junit-jupiter', version: '5.9.2'],
    [group: 'org.junit.jupiter', name: 'junit-jupiter-api', version: '5.9.2'],
    [group: 'org.junit.jupiter', name: 'junit-jupiter-engine', version: '5.9.2'],
    [group: 'org.junit.platform', name: 'junit-platform-launcher', version: '1.9.2'],
    // Because reasons: https://blog.adamretter.org.uk/xerces-xsd11-maven/
    [group: 'org.exist-db.thirdparty.xerces', name: 'xercesImpl', version: '2.12.2' ],
    files("src/test/resources/data1.jar"),
    files("src/test/resources/data2.jar"),
    files("src/test/resources/data3.jar"),
    files("${buildDir}/libs/xmlresolver-${resolverVersion}-data.jar")
  )

  testRuntimeOnly("org.junit.platform:junit-platform-launcher")
}

test {
  useJUnitPlatform {
  }
}

tasks.withType(Test) {
  useJUnitPlatform() {
  }
  testLogging {
    //events "passed"
  }
}

import org.gradle.internal.os.OperatingSystem;
import com.nwalsh.gradle.saxon.SaxonXsltTask
import com.nwalsh.gradle.docker.DockerContainer

ext {
  c_restest = "restest"
}

String runtimeClasspath = "lib/xmlresolver-${resolverVersion}.jar"
String EXCP="${projectDir}/build/classes/java/main"
configurations.standaloneClasspath.each { it ->
  if (!it.name.startsWith("data") && !it.name.startsWith("xmlresolver")) {
    runtimeClasspath += " lib/" + it.name
  }
}

buildConfig {
  packageName("org.xmlresolver")
  buildConfigField('String', 'appName', "\"org.xmlresolver\"")
  buildConfigField('String', 'VERSION', "\"${resolverVersion}\"")
}

docker_container.configure {
  workingDir = "docker"
}

// ============================================================

if (OperatingSystem.current().isWindows()) {
  task buildData(type: Exec) {
    workingDir "data"
    commandLine "cmd", "/c", ".\\gradlew", "dist"
  }
} else {
  task buildData(type: Exec) {
    workingDir "data"
    commandLine "./gradlew", "dist"
  }
}

task copyData(dependsOn: ["buildData"]) {
  def srcpath = null
  doFirst {
    File databuild = new File("data/build")
    databuild.listFiles().each { fnfile ->
      def fn = fnfile.toString().replace("\\", "/") // Normalize for Windows
      if (fn.toString().startsWith("data/build/xmlresolverdata")) {
        if (srcpath != null) {
          throw new GradleException("More than one version of the data?")
        }
        srcpath = fn.toString()
      }
    }
  }
  doLast {
    if (srcpath == null) {
      throw new GradleException("No data?")
    } else {
      copy {
        into "${buildDir}/data/org/xmlresolver"
        from "${projectDir}/${srcpath}"
      }
    }
  }
}

// ============================================================

tasks.register('xmljavadoc', Javadoc) {
  classpath = configurations.docletConfiguration
  source = sourceSets.main.allJava
  destinationDir = file("${buildDir}/xmldoc")
  options.doclet = 'com.saxonica.xmldoclet.XmlDoclet'
  options.docletpath = configurations.docletConfiguration.files.asType(List)
  options.addStringOption("sourcepath", "${projectDir}/src/main/java:${buildDir}/generated/source/buildConfig/main/main")
}

jar {
  archiveBaseName = "${basename}-${resolverVersion}"
  manifest {
    attributes "Built-By": "Norman Walsh"
    attributes "Implementation-Vendor": "Norman Walsh"
    attributes "Implementation-Title": "XML Resolver"
    attributes "Implementation-Version": resolverVersion
    attributes "Automatic-Module-Name": "org.xmlresolver.xmlresolver"
  }
}

task copyJars(type: Copy, dependsOn: ["jar", "dataJar"]) {
  from "build/libs"
  into "build/${basename}-${resolverVersion}/lib"
  doFirst {
    mkdir "build/${basename}-${resolverVersion}/lib"
  }
}

task copyDocs() {
  doFirst {
    mkdir "build/${basename}-${resolverVersion}"
  }
  doLast {
    copy {
      from "${projectDir}/docs"
      into "${buildDir}/${basename}-${resolverVersion}/"
      filter { String line ->
        if (line.indexOf("@@") >= 0) {
          line = line
            .replace("@@VERSION@@", resolverVersion)
        }
        line
      }
    }
  }
  doLast {
    copy {
      from projectDir
      into "${buildDir}/${basename}-${resolverVersion}/"
      include "LICENSE.md"
    }
  }
}

task dist(dependsOn: ["copyDocs", "copyJars", "test"], type: Zip) {
  from("build/${basename}-${resolverVersion}")
  into 'xmlresolver-' + resolverVersion
  archiveFileName = "xmlresolver-${resolverVersion}.zip"
}

javadoc {
  title 'XML Catalog Resolver API'
  exclude 'org/xmlresolver/utils/**'
  exclude 'org/xmlresolver/BuildConfig.java'
  exclude 'org/xmlresolver/ResourceConnection.java'
  exclude 'org/xmlresolver/ResolvedResourceImpl.java'
  exclude 'org/xmlresolver/ResourceResolverImpl.java'
  exclude 'org/xmlresolver/cache/CacheEntryCatalog.java'
  exclude 'org/xmlresolver/catalog/**'
  options.showFromPublic()
  options.overview = 'src/main/java/overview.html'
  options.encoding('utf-8')
  options.docEncoding('utf-8')
  options.charSet('utf-8')
}

task javadocJar(type: Jar, dependsOn: javadoc) {
  archiveBaseName = "${basename}-${resolverVersion}"
  archiveClassifier = 'javadoc'
  from javadoc.destinationDir
  manifest {
    attributes "Built-By": "Norman Walsh"
    attributes "Implementation-Vendor": "Norman Walsh"
    attributes "Implementation-Title": "XML Resolver API documentation"
    attributes "Implementation-Version": resolverVersion
    attributes "Automatic-Module-Name": "org.xmlresolver.xmlresolver_javadoc"
  }
}
assemble.dependsOn javadocJar

task sourcesJar(type: Jar, dependsOn: ["generateBuildConfig"]) {
  archiveBaseName = "${basename}-${resolverVersion}"
  archiveClassifier = 'sources'
  from sourceSets.main.allSource
  manifest {
    attributes "Built-By": "Norman Walsh"
    attributes "Implementation-Vendor": "Norman Walsh"
    attributes "Implementation-Title": "XML Resolver sources"
    attributes "Implementation-Version": resolverVersion
    attributes "Automatic-Module-Name": "org.xmlresolver.xmlresolver_sources"
  }
}
assemble.dependsOn sourcesJar

task dataJar(type: Jar, dependsOn: ["copyData"]) {
  archiveBaseName = "${basename}-${resolverVersion}"
  archiveClassifier = 'data'
  from "${buildDir}/data"
  manifest {
    attributes "Built-By": "Norman Walsh"
    attributes "Implementation-Vendor": "Norman Walsh"
    attributes "Implementation-Title": "XML Resolver data"
    attributes "Implementation-Version": resolverVersion
    attributes "Automatic-Module-Name": "org.xmlresolver.xmlresolver_data"
  }
}
assemble.dependsOn dataJar
test.dependsOn dataJar
compileTestJava.dependsOn dataJar

signing {
  sign publishing.publications
}

publishing {
  publications {
    mavenJava(MavenPublication) {
      pom {
        suppressPomMetadataWarningsFor('validatingApiElements')
        suppressPomMetadataWarningsFor('validatingRuntimeElements')

        name = 'XML Resolver'
        packaging = 'jar'
        description = 'An XML entity/uri resolver'
        url = 'https://github.com/xmlresolver/xmlresolver'

        scm {
          url = 'scm:git@github.com:xmlresolver/xmlresolver.git'
          connection = 'scm:git@github.com:xmlresolver/xmlresolver.git'
          developerConnection = 'scm:git@github.com:xmlresolver/xmlresolver.git'
        }

        licenses {
          license {
            name = 'Apache License version 2.0'
            url = 'https://www.apache.org/licenses/LICENSE-2.0'
            distribution = 'repo'
          }
        }

        developers {
          developer {
            id = 'ndw'
            name = 'Norman Walsh'
          }
        }
      }

      artifactId = basename
      version = resolverVersion
      from components.java
      artifact javadocJar
      artifact sourcesJar
      artifact dataJar
    }
  }

  repositories {
    if (project.findProperty("mavenLocalPublish") != null) {
      maven {
        url = project.findProperty("mavenLocalPublish")
      }
    } else {
      maven {
        url = resolverVersion.contains("SNAPSHOT") ?
          "https://oss.sonatype.org/content/repositories/snapshots/" :
          "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
        credentials {
          username = findProperty("sonatypeUsername") ?: ""
          password = findProperty("sonatypePassword") ?: ""
        }
      }
    }
  }
}

task deleteBuild() {
  delete "build"
}

clean.dependsOn deleteBuild

// ======================================================================

tasks.register("dockerup") {
  description "Make sure the Docker container is running."
  doLast {
    if (!DockerContainer.running(c_restest)) {
      DockerContainer.compose {
        command = "up"
        options = ["-p", "xmlres"]
        args = "-d"
      }
    }
  }
  finalizedBy "dockerstatus"
}
test.dependsOn dockerup

tasks.register("dockerdown") {
  description "Make sure the Docker container is not running."
  doLast {
    if (DockerContainer.running(c_restest)) {
      DockerContainer.compose {
        command = "down"
        options = ["-p", "xmlres"]
      }
    }
  }
  finalizedBy "dockerstatus"
}

tasks.register("dockerstatus") {
  description "Print a short summary of running containers"
  doLast {
    if (DockerContainer.containers().isEmpty()) {
      println("There are no docker containers running.")
    } else {
      DockerContainer.docker( {
        command = "ps"
        args = ["-a", "--format={{.ID}} {{.Names}} {{.Status}}"]
      })
    }
  }
}

// ======================================================================

task helloWorld() {
  // My task for testing
  doLast {
    println("Hello, world.")
  }
}