build.gradle

import java.nio.file.Files
import java.nio.file.Paths
import static java.nio.file.attribute.PosixFilePermissions.*

buildscript {
    repositories {
        mavenCentral()
    }

    dependencies {
        classpath 'commons-io:commons-io:2.4'
        classpath 'org.apache.ant:ant:1.10.7'
    }
}

plugins {
    id 'application'
    id 'groovy'
    id 'java-library'
    id 'maven-publish'
    //see https://github.com/researchgate/gradle-release
    id 'net.researchgate.release' version '2.8.1'
}

// Warning: -Xss is restricted in recent Java versions.
def factGenXmx='12000m'
def factGenStack='1000m'
def defaultFactGenJvmArgs = ["-DmaxHeapSize=${factGenXmx}", "-DstackSize=${factGenStack}"]

// Should the fact generators be linked as normal Java libraries? By
// default this is false, as this integrates many (possibly duplicate
// or incompatible) libraries due to the different front ends.
boolean linkFactGenerators = project.hasProperty('linkFactGenerators') ? project.property('linkFactGenerators') : false

sourceCompatibility = "1.8"
targetCompatibility = "1.8"

group = "org.clyze"

// Doop entry point.
mainClassName = "org.clyze.doop.Main"

// Windows support flag.
def onWindows = System.properties['os.name'].toLowerCase().contains('windows')

def heapDLVersion = "1.1.13"
if (project.hasProperty('heapDLVersion'))
    heapDLVersion = project.property('heapDLVersion')

wrapper {
    gradleVersion = "7.3.3"
}

def allGeneratorProjects = subprojects.findAll { it.name.contains('fact-generator') }
def codeProcessorProject = project(':generators:code-processor')
(allGeneratorProjects + codeProcessorProject).each {
    //common configuration for all generator sub-projects
    it.with {
        apply(plugin: 'java')

        group = gradle.rootProject.group
        sourceCompatibility = gradle.rootProject.sourceCompatibility
        targetCompatibility = gradle.rootProject.targetCompatibility

        repositories {
            mavenLocal()
            mavenCentral()
            maven { url 'https://clyze.jfrog.io/artifactory/default-maven-local' }
            // maven {
            //     url "http://centauri.di.uoa.gr:8081/artifactory/plast-public"
            //     allowInsecureProtocol true    // for Gradle 7 compatibility
            // }
        }
    }
}

// Set variables for subprojects.
gradle.rootProject.ext.resourcesDir='src/main/resources'
gradle.rootProject.ext.testResourcesDir='src/test/resources'

def frontendGeneratorProjects = allGeneratorProjects.findAll { it.name.contains('-fact-generator') }
//all frontends have a fatJar task, which we explicitly (re)define it here, so we can reference it without issues in
//the publishing spec
frontendGeneratorProjects.each { Project p ->
    p.with {
        version = null
    }
    // fatJar
    p.tasks.create('fatJar', Jar)
    p.tasks.fatJar.dependsOn p.tasks.jar
    distZip.dependsOn p.tasks.fatJar
    // installJar
    p.tasks.create('installJar', Copy)
    p.tasks.installJar {
	    from p.tasks.fatJar.outputs.files.singleFile
	    into p.file("../../${resourcesDir}")
    }
    p.tasks.installJar.dependsOn p.tasks.fatJar
    // uninstallJar
    p.tasks.create('uninstallJar')
    p.tasks.uninstallJar() {
	    doLast {
            def jar = p.tasks.fatJar.outputs.files.singleFile
            if (jar && jar.name) { delete p.file("../../${resourcesDir}/${jar.name}") }
	    }
    }
}

repositories {
    mavenLocal()
    mavenCentral()
    // maven { url "http://centauri.di.uoa.gr:8081/artifactory/plast-deps" }
    // maven {
    //     url "http://centauri.di.uoa.gr:8081/artifactory/plast-public"
    //     allowInsecureProtocol true // for Gradle 7 compatibility
    // }
    maven { url 'https://clyze.jfrog.io/artifactory/default-maven-local' }
    maven { url 'https://jitpack.io' }
    maven {
        name "soot-snapshot"
        url "https://soot-build.cs.uni-paderborn.de/nexus/repository/soot-snapshot"
    }
    maven {
        name "soot-release"
        url "https://soot-build.cs.uni-paderborn.de/nexus/repository/soot-release"
    }
}

configurations {
    apktool {
        transitive = false
    }
}

configurations.all {
    //This is required for SNAPSHOT dependencies
    resolutionStrategy.cacheChangingModulesFor 0, 'seconds'
    //This is required for dependencies using the "+" notation
    resolutionStrategy.cacheDynamicVersionsFor 0, 'seconds'
}

compileGroovy {
    groovyOptions.optimizationOptions.indy = true
}

// Set dependency version so that they are available to subprojects.
gradle.rootProject.ext.antlrVersion='4.9.1'
gradle.rootProject.ext.commonsCliVersion='1.2'
gradle.rootProject.ext.metadataVersion='2.4.1'
gradle.rootProject.ext.groovyVersion='3.0.9'
gradle.rootProject.ext.clueCommonVersion='3.25.3'
gradle.rootProject.ext.log4jVersion='1.2.17'
gradle.rootProject.ext.spockVersion='2.1-M2-groovy-3.0'

dependencies {
    // apktool "ext:apktool:2.4.0"                              // old artifactory dependency
    // apktool 'Apktool-fork.brut.apktool:apktool-cli:2.4.2'    // artifactory dependency
    apktool files('local-dependencies/apktool-cli-2.4.2.jar')   // needed for decoding APK inputs
    api project(path: ':generators:fact-generator-common', configuration: 'shadow')
    api codeProcessorProject
    implementation "org.codehaus.groovy:groovy:${groovyVersion}",      // Groovy
            "org.codehaus.groovy:groovy-ant:${groovyVersion}",
            "org.codehaus.groovy:groovy-cli-commons:${groovyVersion}", // Command line processor (Groovy wrapper)
            "commons-logging:commons-logging:1.1",              // Logging wrapper
            "log4j:log4j:${log4jVersion}",                      // Logging implementation
            "commons-cli:commons-cli:${commonsCliVersion}",     // Command line processor
            "commons-io:commons-io:2.4",                        // File Utils
            "org.clyze:clue-common:${clueCommonVersion}"
    api "org.clyze:HeapDL:$heapDLVersion"
    implementation "com.google.guava:guava:27.1-jre"                   // for Scaler

    runtimeOnly "org.clyze:jphantom:1.3"                            // JPhantom is a runtime dependency

    testImplementation "org.spockframework:spock-core:${spockVersion}"
}

// If fact generators are linked, mark them as dependencies and set up
// an appropriate environment.
if (linkFactGenerators) {
    dependencies {
        runtime project(':generators:dex-fact-generator')
        runtime project(':generators:soot-fact-generator')
        runtime project(':generators:wala-fact-generator')
    }
    def jvmMemArgs = ["-Xmx${factGenXmx}", "-Xss${factGenStack}"] as List<String>
    application {
        applicationDefaultJvmArgs = jvmMemArgs
    }
    test {
        jvmArgs jvmMemArgs
    }
}
// Otherwise, pass the memory options for Doop to use when invoking fact generators.
else {
    application {
        applicationDefaultJvmArgs = defaultFactGenJvmArgs
    }
}

applicationDistribution.from(file("$projectDir/logic")) {
    into 'logic'
}

applicationDistribution.from(file("$projectDir/souffle-logic")) {
    into 'souffle-logic'
}

applicationDistribution.from(file("$projectDir/bin")) {
    into 'bin'
}

applicationDistribution.from(file("${projectDir}/${resourcesDir}")) {
    into resourcesDir
}

applicationDistribution.from(projectDir) {
    include 'docs', 'COLLABORATORS', 'LICENSE', 'README.md'
}

def testSubprojects = [ '016-reflection', '104-method-references', '107-lambdas', '115-invokedynamic' ]

testSubprojects.each {
    def path = "tests/${it}/build/libs"
    applicationDistribution.from(file("$projectDir/${path}")) { into path }
}

String doopCP() {
    return String.join(":", sourceSets.main.runtimeClasspath.collect { it.toString() })
}

task writeGitCommitHash() {
    String hash
    if (file('.git').exists()) {
	def stdout = new ByteArrayOutputStream()
	exec {
            commandLine 'git', 'rev-parse', 'HEAD'
            standardOutput = stdout
            ignoreExitValue = true
	}
	hash = stdout.toString().trim()
    } else
	hash = ''
    new File(projectDir, "${resourcesDir}/git-hash.txt").withWriter { w -> w.writeLine(hash) }
}
[jar, run].each { it.dependsOn writeGitCommitHash }

jar {
    manifest {
        attributes 'Implementation-Version' : archiveVersion.get()
    }
}

run {
    //debug true
    // We set the DOOP_HOME environment variable (see org.clyze.doop.Main)
    environment.DOOP_HOME = projectDir
    if (project.hasProperty('args')) {
        def splitArgs = org.apache.tools.ant.types.Commandline.translateCommandline(project.property('args'))
        args splitArgs
    }
}

// Auxiliary task to print the environment variable needed for
// isolated execution of Soot-based front end.
task printExtClasspath {
    doLast {
        println(doopCP())
    }
}

task zipper(type: JavaExec) {
    description 'Run Zipper'
    group = 'Doop'
    main = 'ptatoolkit.zipper.doop.Main'
    classpath = sourceSets.main.runtimeClasspath.filter {
        !it.name.startsWith("scaler")
    }
    if (project.hasProperty("args"))
        args project.property("args").split()
    //jvmArgs = ['-Xmx=48g']
}

task soot(type: JavaExec) {
    description 'Run Soot front-end'
    group = 'Doop'
    main = 'org.clyze.doop.soot.Main$Standalone'
    classpath = sourceSets.main.runtimeClasspath
    if (project.hasProperty("args"))
        args project.property("args").split()
    //jvmArgs = ['-Xmx=48g']
}


task souffleScript(type: JavaExec) {
    description 'Run a custom Souffle script'
    group = 'Doop'
    main = 'org.clyze.doop.utils.SouffleScriptMain'
    classpath = sourceSets.main.runtimeClasspath
    if (project.hasProperty("args"))
        args project.property("args").split()
}

task xtractor(type: JavaExec) {
    // We set the DOOP_HOME environment variable (see org.clyze.doop.Main)
    environment.DOOP_HOME = projectDir
    description 'Run xTractor logic'
    group = 'Doop'
    main = 'org.clyze.doop.utils.XTractor'
    classpath = sourceSets.main.runtimeClasspath
    if (project.hasProperty("args"))
        args project.property("args").split()
}

def testNames = new File(this.projectDir, "src/inputTests").list()

sourceSets {
    testNames.each { t -> "$t" { java { srcDirs = ["src/inputTests/$t"] } } }
}

testNames.each {name ->
    task "${name}JAR"(type:Jar, dependsOn: "${name}Classes") {
        group = 'other'
        from sourceSets.getByName(name).output.classesDirs
        archiveFileName.set("${name}.jar")
        manifest { attributes 'Main-Class': "A" }
        xtractor.dependsOn it
    }
}


task createEmptyProperties {
    doLast {
        def urls = sourceSets.main.runtimeClasspath.files.collect { it.toURI().toURL() } as URL[]
        def classloader = new URLClassLoader(urls, null as ClassLoader)
        Class
            .forName("org.clyze.doop.CommandLineAnalysisFactory", true, classloader)
            .createEmptyProperties(new File("empty.properties"))
    }
}

task resolveApktool {
    doLast {
        copy {
            from configurations.apktool.files[0]
            into "${projectDir}/${resourcesDir}"
        }
    }
}

compileJava {
    options.compilerArgs << '-Xlint:unchecked'
}

test {
    useJUnitPlatform()
    // failFast = true
    maxParallelForks = 1
    // forkEvery = 1
    jvmArgs.addAll(['-DreservedCodeCacheSize=1g'] + defaultFactGenJvmArgs)
    testLogging {
        exceptionFormat = 'full'
    }
    environment.DOOP_HOME = projectDir
    File tmpDir = new File(getTmpDir())
    tmpDir.mkdirs()    // needed for 'clean' targets
    java.nio.file.Path lbTestHomeDir = Files.createTempDirectory(tmpDir.toPath(), 'lb-test-home-dir', onWindows ? ([] as java.nio.file.attribute.FileAttribute[]) : asFileAttribute(fromString("rwxrwxrwx")))
    environment.HOME = lbTestHomeDir.toString()
}
// Workaround from https://stackoverflow.com/questions/4597850/gradle-build-without-tests/4600845#4600845
// since "./gradlew release -x test" may be broken in recent Gradle releases.
test.onlyIf { ! Boolean.getBoolean('skip.tests') }

// Copy resources to src/test/resources or they will not be found by tests.
task copyResourcesForTest {
    doLast {
        copy {
            from file(resourcesDir)
            into testResourcesDir
        }
    }
}
task buildTests {
    description 'Build test subprojects.'
}
testSubprojects.each { buildTests.dependsOn("tests:${it}:jar") }
test.dependsOn buildTests

task testAll(type: Test) { }
testAll.dependsOn test

// Task that configures installing/cleaning resources.
task resourceInstaller { }
resourceInstaller.dependsOn resolveApktool
frontendGeneratorProjects.collect { it.name }.each { fg ->
    resourceInstaller.dependsOn(":generators:${fg}:installJar")
    clean.dependsOn(":generators:${fg}:uninstallJar")
    testAll.dependsOn(":generators:${fg}:test")
}
processResources.dependsOn resourceInstaller

// Ensure that all resources have been built before trying to copy them.
copyResourcesForTest.dependsOn resourceInstaller
test.dependsOn copyResourcesForTest

task cleanTestResources {
    doLast {
        file(resourcesDir).eachFileRecurse { File f ->
            if (f.file) {
                File testResource = new File(file(testResourcesDir), f.name)
                if (testResource.exists())
                    org.apache.commons.io.FileUtils.deleteQuietly(testResource)
            }
        }
    }
}
clean.dependsOn cleanTestResources

def getTmpDir() { return System.getenv('DOOP_TMP')   ?: "$projectDir/tmp" }

task fullClean {
    description 'Clean everything, including caches and analysis results.'
    doLast {
        def out   = System.getenv('DOOP_OUT')   ?: "$projectDir/out"
        def cache = System.getenv('DOOP_CACHE') ?: "$projectDir/cache"
        def tmp   = getTmpDir()
        file(out      ).list().each { f -> delete "$out/$f" }
        file(cache    ).list().each { f -> delete "$cache/$f" }
        file(tmp      ).list().each { f -> delete "$tmp/$f" }
        file('results').list().each { f -> delete "results/$f" }
        org.apache.commons.io.FileUtils.deleteQuietly(new File('last-analysis'))
    }
}
fullClean.dependsOn clean

task printClasspath {
    doLast {
        configurations.compile.each { println it }
    }
}

task sourcesJar(type: Jar, dependsOn: classes) {
    archiveClassifier.set('sources')
    from sourceSets.main.allSource
    exclude("*.jar")
}

task javadocJar(type: Jar, dependsOn: javadoc) {
    archiveClassifier.set('javadoc')
    from javadoc.destinationDir
}

artifacts {
    archives sourcesJar
    archives javadocJar
}

// Make publishing tasks trigger subproject builds.
Closure shadowDep = { Task it ->
    it.dependsOn(':generators:fact-generator-common:shadowJar')
    it.dependsOn(':generators:code-processor:jar')
}
tasks.withType(PublishToMavenRepository) { shadowDep(it) }
tasks.withType(PublishToMavenLocal) { shadowDep(it) }

if (project.hasProperty('artifactory_user')) {

    // Generate a jar with all the logic files
    task logicFilesJar(type: Jar) {
        into('souffle-logic') { from "souffle-logic" }
    }

    publishing {
        publications {
            mavenJava(MavenPublication) {
                from components.java
                artifact tasks.sourcesJar
                artifact tasks.javadocJar

                artifact logicFilesJar {
                    classifier "logic-files"
                }
            }

            // Publish fact-generator-common and code-processor.
            [[project(':generators:fact-generator-common'), "fact-generator-common-${version}-all.jar"],
	         [codeProcessorProject, "code-processor-${version}.jar"]]
            .forEach { List l ->
                Project p = l[0]
                create(p.name, MavenPublication) {
                    // The artifact generator can be a file or a Gradle task
                    def artifactGenerator = p.file('build/libs/' + l[1])
                    artifact(artifactGenerator) {
                        groupId 'org.clyze'
                        artifactId p.name
                    }
                }
            }
        }

        repositories {
            maven {
                credentials {
                    username artifactory_user
                    password artifactory_password
                }
                url "$artifactory_contextUrl/libs-public-release-local"
                allowInsecureProtocol true
            }
        }
    }

    release {
        failOnSnapshotDependencies = false

        git {
           commitVersionFileOnly = true
        }
    }

    afterReleaseBuild.dependsOn publish

    tasks.release.doLast {
        println "WARNING: Tag may not be pushed upstream, please use:"
        println "WARNING:   git remote add upstream <UPSTREAM_REPO>"
        println "WARNING:   git push upstream <TAG>"
    }
}

/* Handy for debugging task dependencies
gradle.taskGraph.whenReady {taskGraph ->
    println "Found task graph: " + taskGraph
    println "Found " + taskGraph.allTasks.size() + " tasks."
    taskGraph.allTasks.forEach { task ->
        println task
        task.dependsOn.forEach { dep ->
            println "  - " + dep
        }
    }
}
*/