build-system/gradle-core/build.gradle

apply plugin: 'java'
apply plugin: 'kotlin'
apply plugin: 'jacoco-tools-base'
apply plugin: 'clone-artifacts'
apply plugin: 'antlr'
apply plugin: 'com.google.protobuf'

protobuf {
    protoc {
        artifact = 'com.google.protobuf:protoc:3.0.0'
    }
}

configurations {
    provided
    includeInJar
}

// Incremental update test support
File classesDir = new File(project.buildDir, "classes/incremental-test")
File baseClasses = new File(classesDir, "base")
File baseInstrumentedClasses = new File(classesDir, "baseInstrumented")

sourceSets {
    main {
        java.srcDirs += 'src/fromGradle/java'
        resources.srcDirs = ['src/main/resources', 'src/fromGradle/resources']
        compileClasspath += configurations.provided
    }

    test {
        compileClasspath += files(baseClasses)
        runtimeClasspath += files(baseInstrumentedClasses)
    }
}

dependencies {
    compileOnly libs.auto_value

    compile project(':base:builder')
    compile project(':base:lint')
    compile project(':base:uast')
    compile project(':base:gradle-api')
    compile project(':dataBinding:compilerCommon')

    compile libs.kotlin_stdlib
    compile libs.transform_api_deprecated
    compile libs.asm
    compile libs.asm_analysis
    compile libs.asm_commons
    compile libs.asm_util
    compile libs.jacoco_core, {
      exclude group: 'org.ow2.asm', module: 'asm-debug-all'
    }
    compile libs.jacoco_report, {
      exclude group: 'org.ow2.asm', module: 'asm-debug-all'
    }
    compile libs.jopt
    compile libs.kotlin_stdlib
    compile libs.proguard
    compile libs.protobuf

    testCompile project(':base:instant-run:instant-run-annotations')
    testCompile project(':base:instant-run:instant-run-runtime')


    // Add gradleApi to classpath for compilation, but use provided configuration so that groovy is
    // not exposed as a runtime dependency.
    provided gradleApi()

    // Package the instant-run-server.jar, nothing else.
    includeInJar project(path: ':base:instant-run:instant-run-server', configuration: 'archives')

    antlr libs.antlr3

    testCompile gradleApi()
    testCompile libs.junit
    testCompile libs.truth
    testCompile libs.mockito_core
    testCompile libs.guava
	testCompile libs.equalsverifier
    testCompile project(':base:project-test-lib')
    testCompile project(':base:testutils')
    testCompile libs.jsoup
}

jar {
    into('instant-run') {
        from configurations.includeInJar
    }
}

group = 'com.android.tools.build'
archivesBaseName = 'gradle-core'
version = rootProject.ext.buildVersion

project.ext.pomName = 'Core Library for Android Gradle Plug-in'
project.ext.pomDesc = 'Core library to build Android Gradle plugin.'

apply from: "$rootDir/buildSrc/base/publish.gradle"
apply from: "$rootDir/buildSrc/base/bintray.gradle"

test {
    environment("CUSTOM_REPO",
            rootProject.file("../out/repo").toString()
                    + File.pathSeparator
                    + rootProject.file("../prebuilts/tools/common/m2/repository/").toString())

    testLogging {
        events "failed"
    }

    maxParallelForks = Runtime.runtime.availableProcessors() / 2

    exclude "**/GradleCoreBazelSuite*"
}

javadoc {
    exclude     "**/internal/**"

    options.docTitle "Gradle Plugin for Android"
    options.header ""
    options.footer "Copyright (C) 2012 The Android Open Source Project"
}

task javadocJar(type: Jar, dependsOn:javadoc) {
    classifier  'javadoc'
    from        javadoc.destinationDir

}

tasks.withType(Javadoc) {
    classpath += configurations.provided
}

// Only package JavaDoc if using --init-script=buildSrc/base/release.gradle
if (project.hasProperty("release")) {
    artifacts {
        archives javadocJar
    }
}


// Package instant run instrumentation inside of gradle-core.
configurations {
    subsumedProvided
    sourcesSubsumedProvided
}
dependencies {
    subsumedProvided(project(':base:instant-run-instrumentation')) {
        transitive = false
    }
    sourcesSubsumedProvided(project(path:':base:instant-run-instrumentation', configuration:'sourcesOnly')) {
        transitive = false
    }
}
sourceSets.main.compileClasspath += configurations.subsumedProvided
sourceSets.test.compileClasspath += configurations.subsumedProvided
sourceSets.test.runtimeClasspath += configurations.subsumedProvided
tasks.compileJava.dependsOn(configurations.subsumedProvided)
tasks.sourcesJar.dependsOn(configurations.sourcesSubsumedProvided)
tasks.jar {
    from({ zipTree(configurations.subsumedProvided.singleFile)})
}
tasks.sourcesJar {
    from({zipTree(configurations.sourcesSubsumedProvided.singleFile)})
}
javadoc {
    classpath += configurations.subsumedProvided
}
// End Package instant run instrumentation inside of gradle-core.

// Incremental update test support
javadoc {
    classpath += configurations.provided
}

// setup annotation processor output directory
File generatedSources = new File(project.buildDir, 'generated/generated')
tasks.compileJava {
    doFirst {
        generatedSources.mkdirs()
    }
    options.compilerArgs += ['-s', generatedSources]
    outputs.dir(generatedSources)
}