build.gradle

plugins {
  id "java"
  id 'com.github.eerohele.saxon-gradle' version '0.9.0-beta1'
  id "de.undercouch.download" version "4.0.4"
}

sourceSets { }

import com.github.eerohele.SaxonXsltTask
import org.gradle.internal.os.OperatingSystem

repositories {
  mavenLocal()
  mavenCentral()
}

configurations {
  saxonee
}

configurations.all {
  resolutionStrategy {
    force 'xml-apis:xml-apis:1.4.01'
  }
}

dependencies {
  saxonee fileTree(dir: "lib/${saxonVersion}").include("*.jar")
  implementation (
    [group: 'net.sf.saxon', name: 'Saxon-HE', version: saxonVersion],
  )
}

defaultTasks 'testXSpec'

def gitRef() {
  def ref = ""
  def proc = "git rev-parse --short --verify HEAD".execute()
  proc.in.eachLine { line ->
    ref = line
  }
  proc.err.eachLine { line ->
    println(line)
  }
  proc.waitFor()
  ref
}

def heAvailable=true
def eeAvailable=false
def peAvailable=false
configurations.saxonee.each { it ->
  eeAvailable = eeAvailable || it.toString().contains("saxon-ee")
  peAvailable = peAvailable || it.toString().contains("saxon-pe")
}
configurations.compileClasspath.each { it ->
  eeAvailable = eeAvailable || it.toString().contains("saxon-ee")
  peAvailable = peAvailable || it.toString().contains("saxon-pe")
}

// This is all a complete hack that I worked out by trial and error
def EXCP=""
def EXCPSEP=""
if (saxonEE != "false" && (eeAvailable || peAvailable)) {
  configurations.saxonee.each { it ->
    EXCP += EXCPSEP + it
    EXCPSEP = ":"
  }
} else {
  configurations.compileClasspath.each { it ->
    EXCP += EXCPSEP + it
    EXCPSEP = ":"
  }
}

// System.getenv().each{ k, v -> println "${k}:${v}" }

// Should we force an XSPec failure to kill the build?
def CIRCLECI = System.getenv('CIRCLECI') == "true"
def failOnErrors = CIRCLECI || "true".equals(failOnXSPecErrors)

task configureEnvironment() {
  def envVars = [:]
  envVars['TEST_DIR'] = buildDir
  envVars['SAXON_CP'] = EXCP
  tasks.withType(Exec) {
    environment << envVars
  }
}

task downloadXSpec(type: Download) {
  src "https://github.com/xspec/xspec/archive/v${xspecVersion}.zip"
  dest file("${buildDir}/xspec-${xspecVersion}.zip")
  doFirst {
    mkdir(buildDir)
  }
}
downloadXSpec.onlyIf {
  !file("${buildDir}/xspec-${xspecVersion}.zip").exists()
}

task setupXSpec(type: Copy, dependsOn: ['downloadXSpec']) {
  def zipFile = file("${buildDir}/xspec-${xspecVersion}.zip")
  def outputDir = buildDir
  from zipTree(zipFile)
  into outputDir
}
setupXSpec.onlyIf {
  !file("${buildDir}/xspec-${xspecVersion}/README.md").exists()
}
def xspecCmd = (OperatingSystem.current().isWindows()) ? 
  "${buildDir}\\xspec-${xspecVersion}\\bin\\xspec.bat" : 
  "${buildDir}/xspec-${xspecVersion}/bin/xspec.sh"

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

// Generate tasks to format each test document
fileTree(dir: "src/test/resources/xslt", include: "*.xsl").each { xsl ->
  // Work out the base filename of the test
  def base = xsl.toString().replace("\\", "/")
  def pos = base.indexOf("/resources/xslt/")
  if (pos > 0) {
    base = base.substring(pos+16)
      .replace("/", "_")
      .replace(".xsl", "")
  }

  // It's very frustrating that these can't use the SaxonXsltTask
  // because the stylesheet doesn't exist at configuration time
  // and so gradle throws an error. *grump*

  def outName = base + ".html"
  Task t = task "${outName}"(type: Exec,
                        dependsOn: ['copyResources', 'makeXslt']) {
    inputs.files fileTree(dir: "src/main/xslt")
    inputs.file(xsl.toString())
    outputs.file("${buildDir}/${outName}")
    commandLine "java", "-cp", EXCP, "net.sf.saxon.Transform",
                xsl.toString(),
                "-xsl:${buildDir}/xslt/explorer.xsl",
                "-l",
                "-o:${buildDir}/${outName}"
  }

  def expName = base + ".expected"
  t = task "${expName}"(type: Exec,
                        dependsOn: ['copyResources', 'makeXslt']) {
    inputs.files fileTree(dir: "src/main/xslt")
    inputs.file(xsl.toString())
    outputs.file("src/test/resources/expected/${base}.html")
    commandLine "java", "-cp", EXCP, "net.sf.saxon.Transform",
                xsl.toString(),
                "-xsl:${buildDir}/xslt/explorer.xsl",
                "-o:src/test/resources/expected/${base}.xml",
                "format=data",
                "source-listings=false",
                "xspec-tests=true"
  }
}

// Generate tasks to run each set of XSpec tests
fileTree(dir: "src/test/xspec").each { xspec ->  // Work out the base filename of the test
  def base = xspec.toString().replace("\\", "/")
  def pos = base.indexOf("/test/xspec/")
  if (pos > 0) {
    base = base.substring(pos+12)
    base = base.replace(".xspec", "")
  }

  def taskname = base.replace("-", "_") + ".xspec"
  if (failOnErrors) {
    Task t = task "${taskname}"(type: Exec, dependsOn: ['setupXSpec', 'makeXslt']) {
      inputs.files fileTree(dir: "src/main/xslt")
      inputs.files fileTree(dir: "src/test/xspec")
      inputs.files fileTree(dir: "src/test/resources")
      outputs.files(fileTree(buildDir) {
        include base + "-result.xml"
      })
      errorOutput = new ByteArrayOutputStream()
      commandLine xspecCmd, xspec.toString()

      ext.output = {
        return errorOutput.toString()
      }
    }
  } else {
  Task t = task "${taskname}"(type: Exec, dependsOn: ['setupXSpec', 'makeXslt']) {
    inputs.files fileTree(dir: "src/main/xslt")
    inputs.files fileTree(dir: "src/test/xspec")
    inputs.files fileTree(dir: "src/test/resources")
    outputs.files(fileTree(buildDir) {
      include base + "-result.xml"
    })
    commandLine xspecCmd, xspec.toString()
    ext.output = {
      return ""
      }
    }
  }
}

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

// self-reference
task ouroboros(type: Exec, dependsOn: ['copyResources', 'makeXslt']) {
  inputs.files fileTree(dir: "src/main/xslt")
  outputs.file("${buildDir}/explorer.html")
  commandLine "java", "-cp", EXCP, "net.sf.saxon.Transform",
              "${buildDir}/xslt/explorer.xsl",
              "-xsl:${buildDir}/xslt/explorer.xsl",
              "-l",
              "-o:${buildDir}/explorer.html"
}

task copyResources(type: Copy) {
  from "src/main/resources"
  include "css/**"
  include "js/**"
  into "${buildDir}"
  filter { String line ->
    if (line.indexOf("@@") >= 0) {
      line = line
        .replace("@@TITLE@@", xsltExplorerTitle)
        .replace("@@VERSION@@", xsltExplorerVersion)
    }
    line
  }
  doFirst {
    mkdir "${buildDir}"
  }
}

task makeVersion(type: SaxonXsltTask) {
  inputs.files "tools/version.xsl"
  outputs.file("${buildDir}/xslt/VERSION.xsl")
  input "tools/version.xsl"
  stylesheet "tools/version.xsl"
  output "${buildDir}/xslt/VERSION.xsl"
  parameters(
    "title": xsltExplorerTitle,
    "version": xsltExplorerVersion,
    "gitref": gitRef()
  )
  doFirst {
    mkdir "${buildDir}/xslt"
  }
}

task makeXslt(type: Copy, dependsOn: ['makeVersion', 'copyResources']) {
  outputs.file("${buildDir}/xslt/explorer.xsl")
  from "src/main/xslt"
  into "${buildDir}/xslt"
}

task testXSpec(dependsOn: ["explorer.xspec"]) {
  doLast {
    Task t = tasks.findByName("explorer.xspec")
    def fail = false
    t.output().split("\n").each { line ->
      fail = fail || line.trim().equals("FAILED")
      println(line)
    }
    if (fail) {
      throw new GradleException("XSpec did not pass")
    }
  }
}

test.dependsOn testXSpec

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

task distCopyResources(type: Copy) {
  from "src/main/resources"
  include "css/**"
  include "js/**"
  into "${buildDir}/xsltexplorer-${xsltExplorerVersion}"
  filter { String line ->
    if (line.indexOf("@@") >= 0) {
      line = line
        .replace("@@TITLE@@", xsltExplorerTitle)
        .replace("@@VERSION@@", xsltExplorerVersion)
    }
    line
  }
  doFirst {
    mkdir "${buildDir}/xsltexplorer-${xsltExplorerVersion}"
  }
}

task distCopyXslt(type: Copy, dependsOn: ['makeXslt']) {
  from "${buildDir}/xslt"
  into "${buildDir}/xsltexplorer-${xsltExplorerVersion}/xslt"
  doFirst {
    mkdir "${buildDir}/xsltexplorer-${xsltExplorerVersion}/xslt"
  }
}

task distCopyMisc(type: Copy) {
  from "."
  into "${buildDir}/xsltexplorer-${xsltExplorerVersion}"
  include "README.org"
  include "LICENSE"
  doFirst {
    mkdir "${buildDir}/xsltexplorer-${xsltExplorerVersion}"
  }
}

task zipDist(type: Zip,
             dependsOn: ['distCopyResources','distCopyMisc','distCopyXslt']) {
  from("${buildDir}/xsltexplorer-${xsltExplorerVersion}")
  into "xsltexplorer-${xsltExplorerVersion}"
  archiveFileName = "xsltexplorer-${xsltExplorerVersion}.zip"
  doFirst {
    mkdir "${buildDir}/distributions"
  }
}

task dist(dependsOn: ['test', 'zipDist']) {
  doLast {
    println("Built dist for ${xsltExplorerTitle} version ${xsltExplorerVersion}")
  }
}

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

// This task just exists as a smoke test for my build file
task helloWorld() {
  doLast {
    println('Hello, world.')
  }
}