build.gradle

import org.gradle.plugins.ide.idea.model.IdeaModel
import org.gradle.plugins.ide.idea.model.IdeaProject

buildscript {
    repositories {
        mavenCentral()
        jcenter()
        maven {
            url 'http://repo.spring.io/plugins-release'
        }
        maven {
            url 'http://oss.sonatype.org/content/repositories/snapshots'
        }
        /* only during EAP builds
        maven {
            url 'http://dl.bintray.com/kotlin/kotlin-eap'
        }
        */
    }
    //noinspection GroovyAssignabilityCheck
    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$version_kotlin"
        classpath "org.springframework.build.gradle:propdeps-plugin:0.0.7"
        classpath 'com.bmuschko:gradle-nexus-plugin:2.3.1'
        classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.4'
        // one day... classpath "org.jetbrains.dokka:dokka-gradle-plugin:0.1-SNAPSHOT"
    }
}

subprojects {
    apply plugin: 'propdeps'
    apply plugin: 'propdeps-maven'
    apply plugin: 'propdeps-idea'
    apply plugin: 'java'
    apply plugin: 'kotlin'

    if (name.endsWith("jdk8")) {
        println("Project ${name} set to JDK 8")
        sourceCompatibility = JavaVersion.VERSION_1_8
        targetCompatibility = JavaVersion.VERSION_1_8
    } else if (name.endsWith("jdk7")) {
        println("Project ${name} set to JDK 7")
        sourceCompatibility = JavaVersion.VERSION_1_7
        targetCompatibility = JavaVersion.VERSION_1_7
    } else  if (name.endsWith("jdk6")) {
        println("Project ${name} set to JDK 6")
        sourceCompatibility = JavaVersion.VERSION_1_6
        targetCompatibility = JavaVersion.VERSION_1_6
    } else {
        println("Project ${name} set to JDK 6 (Default)")
        sourceCompatibility = JavaVersion.VERSION_1_6
        targetCompatibility = JavaVersion.VERSION_1_6
    }

    tasks.withType(JavaCompile) {
        options.encoding = 'UTF-8'
        options.incremental = true
        options.compilerArgs << '-Xlint:unchecked'
    }

    IdeaModel idea = project.idea
    IdeaProject ideaProject = idea.getProject()

    if (ideaProject != null) {
        ideaProject.setJdkName(project.targetCompatibility.getName())
        ideaProject.setLanguageLevel(project.sourceCompatibility.getName())
        if (ideaProject.hasProperty("vcs")) {
            ideaProject.setVcs('Git')
        }
    }

    idea.module {
        downloadJavadoc = true
        downloadSources = true
    }

    repositories {
        mavenCentral()
        maven {
            url 'http://oss.sonatype.org/content/repositories/snapshots'
        }
        /** only during EAP builds
        maven {
            url 'http://dl.bintray.com/kotlin/kotlin-eap'
        }
        */
    }

    dependencies {
        provided "org.jetbrains.kotlin:kotlin-stdlib:$version_kotlin"

        testCompile "junit:junit:$version_junit"
        testCompile "org.jetbrains.kotlin:kotlin-test:$version_kotlin"
        testCompile "org.slf4j:slf4j-api:$version_slf4j"
        // testCompile "org.jetbrains.kotlin:kotlin-reflect:$version_kotlin"
        testRuntime "ch.qos.logback:logback-classic:$version_logback"
    }

    //noinspection GroovyAssignabilityCheck
    configurations.all {
        // kill all logging anything else might bring in, all of our projects use slf4j if any
        exclude group: "org.slf4j", module: "slf4j-simple"
        exclude group: "commons-logging"
        exclude group: "log4j"
        exclude group: "com.google.code.findbugs"
        exclude group: "org.slf4j", module: "slf4j-log4j12"

        resolutionStrategy {
            cacheDynamicVersionsFor 12, 'hours'  // things with wildcard version numbers
            cacheChangingModulesFor 0, 'hours'
            // things with same version, but content of module changes, i.e. SNAPSHOT
        }

    }
}

subprojects {
    apply plugin: 'com.bmuschko.nexus'
    apply plugin: 'com.jfrog.bintray'


    def pomOnlyModule = !(new File("${projectDir.toString()}/src/main/kotlin").exists())
    if (pomOnlyModule) {
        println("Project $name is POM ONLY (has no code of its own)")
    }

    task jars() {
        dependsOn build
    }

    if (pomOnlyModule) {
        artifacts {}
        task subRelease() {
            dependsOn uploadArchives
        }
    }
    else {
        task subRelease() {
            dependsOn jars, uploadArchives
        }
    }

    modifyPom {
        project {
            name 'Injekt for Kotlin'
            description 'Dependency injection library for Kotlin.'
            url 'https://github.com/kohesive/injekt'
            inceptionYear '2015'

            scm {
                url 'https://github.com/kohesive/injekt'
                connection 'scm:https://github.com/kohesive/injekt'
                developerConnection 'scm:git@github.com:kohesive/injekt.git'
            }

            licenses {
                license {
                    name 'MIT'
                    url 'https://github.com/kohesive/injekt/blob/master/LICENSE'
                    distribution 'repo'
                }
            }

            developers {
                developer {
                    id 'apatrida'
                    name 'Jayson Minard'
                    email 'jayson.minard@gmail.com'
                }
            }
        }

    }

    nexus {
        sign = true
    }

    bintray {
        user = "$bintrayUser"
        key = "$bintrayKey"
        pkg {
            repo = 'kohesive'
            name = project.name
            licenses = ['MIT']
            vcsUrl = 'scm:git:git@github.com:kohesive/injekt.git'

            version {
                name = project.version
                desc = 'n/a'
                released = new Date()
            }
            publicDownloadNumbers = false
            configurations = ['archives']
        }
        publish = true
        dryRun = false
    }
}

task wrapper(type: Wrapper) {
    gradleVersion = "$version_gradle"
}

task jars() {
    dependsOn subprojects.jars
}

task release() {
    dependsOn subprojects.subRelease
}


defaultTasks 'clean', 'jars'