build.gradle

/** Build script for Modbat. */
buildscript {
  repositories {
    maven {
      url "https://plugins.gradle.org/m2/"
    }
  }
  dependencies {
    classpath "gradle.plugin.com.palantir.gradle.gitversion:gradle-git-version:0.11.0"
    classpath "gradle.plugin.com.github.maiflai:gradle-scalatest:0.24"
  }
}

plugins {
  id "com.github.maiflai.scalatest" version "0.24"
}

apply plugin: 'application'
mainClassName = 'modbat.mbt.Main'

apply plugin: "com.palantir.git-version"
version gitVersion()
def gitDetails = versionDetails()

allprojects {
    apply plugin: 'scala'

    dependencies {
        compile 'org.scala-lang:scala-library:2.11.12'
    }

    repositories {
        mavenCentral()
    }

    tasks.withType(Jar) {
        destinationDir = file("$rootDir/build")
    }
    jar {
        archiveName = "${jar.baseName}.${jar.extension}"
        manifest {
            attributes 'Specification-Vendor': 'KTH',
                       'Implementation-Vendor': 'KTH',
                       'Implementation-Version': gitDetails.gitHashFull
        }
    }
}

dependencies {
    compile 'org.ow2.asm:asm:4.0'
    compile group: 'com.lihaoyi', name: 'sourcecode_2.11', version: '0.1.7'
    compile group: 'javassist', name: 'javassist', version: '3.12.1.GA'
    compile project(':config')
    compile project(':akka-mock-scheduler')
    testCompile project(':config')
    testCompile 'org.hamcrest:hamcrest-core:1.3'
    testCompile 'junit:junit:4.11'
    testCompile 'org.scalatest:scalatest_2.11:3.0.4'
    testRuntime 'org.pegdown:pegdown:1.4.2'
    testCompile project(':config').sourceSets.test.output
}

jar {
    manifest {
        attributes 'Main-Class': mainClassName,
                   'Name': 'modbat/mbt/',
                   'Specification-Title': 'Modbat: A model-based tester',
                   'Specification-Version': gitDetails.lastTag,
                   'Implementation-Title': 'Modbat'
    }
    from "LICENSE", "README", "CHANGELOG", "asm-LICENSE", "sourcecode-LICENSE", "akka-mock-LICENSE", "javassist-LICENSE"
    from "config/build/classes/java/main", "config/build/classes/scala/main"
    from configurations.runtimeClasspath.findAll { it.name.endsWith('jar') && (
                                            it.name.contains('asm') || 
                                            it.name.contains('javassist') || 
                                            it.name.contains('sourcecode') ||  
                                            it.name.contains('akka-mock') ||
                                            it.name.contains('akka-actor')
                                          ) }.collect { zipTree(it) }
}

apply plugin: "com.github.maiflai.scalatest"

task mkExamplesDir {
    mkdir "$buildDir/examplesJar"
}

task cpExamplesSrc(type: Copy) {
    from "src/test/scala/modbat/examples"
    from "src/test/java/modbat/examples"
    into "$buildDir/examplesJar/modbat/examples"
}

task cpExamplesLicense(type: Copy) {
    from "LICENSE"
    into "$buildDir/examplesJar"
}

task cpModelTemplate(type: Copy) {
    from "src/test/scala/modbat/ModelTemplate.scala"
    into "$buildDir/examplesJar/modbat"
}

task jarExamples(type: Jar) {
    archiveName = "modbat-examples.jar"
    destinationDir = file("$buildDir")

    from "$buildDir/classes/scala/test" include "modbat/examples/**"
    from "$buildDir/classes/java/test" include "modbat/examples/**"
    from "$buildDir/examplesJar" include "**/*.scala"
    from "$buildDir/examplesJar" include "**/*.java"
    from "$buildDir/examplesJar" include "LICENSE"
    exclude "modbat/mbt"
    exclude "modbat/test"
    exclude "modbat/tutorial"
}

task mkTutorialDir {
    mkdir "$buildDir/tutorialJar"
}

task cpTutorialSrc(type: Copy) {
    from "src/test/scala/modbat/tutorial"
    from "src/test/java/modbat/tutorial"
    into "$buildDir/tutorialJar/modbat/tutorial"
}

task cpTutorialLicense(type: Copy) {
    from "LICENSE"
    into "$buildDir/tutorialJar"
}

task cpTutorialModbatJar(type: Copy) {
    from "$buildDir/modbat.jar"
    into "$buildDir/tutorialJar/modbat/tutorial"
}

task jarTutorial(type: Jar) {
    archiveName = "modbat-tutorial.jar"
    destinationDir = file("$buildDir")

    from "$buildDir/classes/scala/test" include "modbat/tutorial/**"
    from "$buildDir/tutorialJar" include "**/*.scala"
    from "$buildDir/tutorialJar" include "**/*.java"
    from "$buildDir/tutorialJar" include "LICENSE"
    from "$buildDir/tutorialJar" include "modbat.jar"
    exclude "modbat/mbt"
    exclude "modbat/test"
    exclude "modbat/examples"
}

task testsJar(type: Jar) {
    archiveName = "modbat-test.jar"
    destinationDir = file("$buildDir")

    from "$buildDir/classes/scala/test" findAll { it.name.endsWith('class') }.collect { zipTree(it) }
    from "$buildDir/classes/java/test" findAll { it.name.endsWith('class') }.collect { zipTree(it) }
    exclude "modbat/examples"
    exclude "modbat/tutorial"
}

tasks.withType(Test)  {
  maxParallelForks = 1
}

task examplesJar {
  dependsOn mkExamplesDir
  dependsOn cpExamplesLicense
  dependsOn cpModelTemplate
  dependsOn cpExamplesSrc
  dependsOn jarExamples
}

task tutorialJar {
  dependsOn jar
  dependsOn mkTutorialDir
  dependsOn cpTutorialLicense
  dependsOn cpTutorialSrc
  dependsOn cpTutorialModbatJar
  dependsOn jarTutorial
}

test {
  dependsOn compileTestJava
  dependsOn compileTestScala
  dependsOn examplesJar
  dependsOn tutorialJar
  dependsOn testsJar
}

assemble {
  dependsOn examplesJar
  dependsOn tutorialJar
}