build.gradle

/*
 * Copyright 2018 Kaidan Gustave
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import org.gradle.plugins.ide.idea.model.IdeaLanguageLevel

buildscript {
    ext {
        kotlin_version = '1.2.51'
        kotlin_json_version = '1.7.2'
        kotlinx_coroutines_version = '0.23.4'
        kotlinx_html_version = '0.6.11'
        ktor_version = '0.9.3'
        kotlin_poet_version = '0.8.0-SNAPSHOT'
        shadow_version = '2.0.1'
        jda_version = '3.7.1_390'
        jda_utilities_version = '2.1.2'
        lavaplayer_version = '1.3.7'
        hocon_version = '1.3.1'
        jsoup_version = '1.10.2'
        youtube_api_version = 'v3-rev189-1.23.0'
        ok_http_version = '3.8.1'
        h2_version = '1.4.196'
        postgresql_version = '9.0-801.jdbc4'
        slf4j_version = '1.7.25'
        logback_version = '1.2.3'
        jagtag_version = '0.5'
        junit_version = '1.2.0'
        jupiter_version = '5.2.0'
    }

    repositories {
        jcenter()
        mavenCentral()
    }

    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-allopen:$kotlin_version"
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
        classpath "com.github.jengelman.gradle.plugins:shadow:$shadow_version"
        classpath "org.junit.platform:junit-platform-gradle-plugin:$junit_version"
    }
}

def ver = [major: 0, minor: 8, revision: 2]

static void createChildExtension(Project target, Project child, String ancestorName = "") {
    if(target == child) return
    def childName = child.name.split('-').collect { it.capitalize() }.join('').uncapitalize()
    def name = ancestorName.isEmpty() ? childName : ancestorName + childName.capitalize()
    target.ext."$name" = { child }
    child.childProjects.values().each {
        createChildExtension(target, it, name)
    }
}

allprojects {
    apply plugin: 'java'
    apply plugin: 'idea'
    apply plugin: 'kotlin'

    group = 'xyz.laxus'
    version = ver.values().join('.')

    sourceCompatibility = 8
    targetCompatibility = 8

    // Create dependency shortcut for every subproject
    rootProject.childProjects.values().each { createChildExtension(project, it) }

    ext {
        dependencies {
            // Kotlin
            kotlinModule = { String module -> "org.jetbrains.kotlin:kotlin-$module:$kotlin_version" }
            kotlinxModule = { String module, String version -> "org.jetbrains.kotlinx:kotlinx-$module:$version" }

            // Kotlinx Coroutines
            kotlinxCoroutines = { String module -> kotlinxModule("coroutines-$module", kotlinx_coroutines_version) }

            // Kotlin Html
            kotlinxHtml = { String module = "jvm" -> kotlinxModule("html-$module", kotlinx_html_version) }

            // Kotlin Json
            kotlinJson = { String module = 'jdk8' -> "me.kgustave:kotlin-json-$module:$kotlin_json_version" }

            // JDA
            jda = { "net.dv8tion:JDA:$jda_version" }
            jdaUtilities = { String module -> "com.jagrosh:jda-utilities-$module:$jda_utilities_version" }

            // Lavaplayer
            lavaplayer = { "com.sedmelluq:lavaplayer:$lavaplayer_version" }

            // Database
            h2 = { "com.h2database:h2:$h2_version" }
            postgres = { "postgresql:postgresql:$postgresql_version" }

            // Configuration
            hocon = { "com.typesafe:config:$hocon_version" }

            // ktor
            ktor = { String module ->
                switch(module) {
                    case "client-okhttp": return "me.kgustave:ktor-$module:0.2.0"
                    default: "io.ktor:ktor-$module:$ktor_version"
                }
            }

            kotlinPoet = { "com.squareup:kotlinpoet:$kotlin_poet_version" }

            // Requests
            youtube = { "com.google.apis:google-api-services-youtube:$youtube_api_version" }
            okHttp = { "com.squareup.okhttp3:okhttp:$ok_http_version" }
            jsoup = { "org.jsoup:jsoup:$jsoup_version" }

            // Logging
            slf4j = { "org.slf4j:slf4j-api:$slf4j_version" }
            logback = { "ch.qos.logback:logback-classic:$logback_version" }

            // Misc
            jagtag = { "com.jagrosh:JagTag:$jagtag_version" }

            // JUnit (test)
            jupiter = { String module -> "org.junit.jupiter:junit-jupiter-$module:$jupiter_version" }
        }
    }

    sourceSets {
        test {
            kotlin.srcDirs += 'src/test/kotlin'

            compileClasspath += main.compileClasspath
            runtimeClasspath += main.runtimeClasspath
        }
    }

    repositories {
        jcenter()
        mavenCentral()
        maven { url = 'https://dl.bintray.com/kotlin/ktor' }
        maven { url = 'https://dl.bintray.com/kaidangustave/maven' }
        maven { url = 'https://jitpack.io/' }
        maven { url = 'https://oss.sonatype.org/content/repositories/snapshots' }
    }

    dependencies {
        compileOnly kotlinModule('stdlib')
        compileOnly kotlinModule("stdlib-jdk8")
        compileOnly kotlinModule("stdlib-jdk7")

        testCompile kotlinModule("test-junit")
        testCompile kotlinModule("reflect")
        testCompile slf4j()
        testCompile logback()
        testCompile jupiter("api")
        testRuntime jupiter("engine")
    }

    kotlin {
        experimental {
            coroutines = 'ENABLE'
        }
    }

    compileKotlin {
        kotlinOptions {
            jvmTarget = '1.8'
        }
    }

    compileTestKotlin {
        kotlinOptions {
            jvmTarget = '1.8'
        }
    }

    def autoModuleName = "laxus${project == rootProject ? '.app' : project.path.replace('-', '.').replace(':', '.')}"

    jar {
        manifest {
            attributes 'Manifest-Version': "${ver.major}.${ver.minor}",
                       'Implementation-Version': "$version",
                       'Kotlin-Version': kotlin_version,
                       'Automatic-Module-Name': autoModuleName
        }
    }

    build {
        dependsOn classes
        dependsOn jar

        jar.mustRunAfter classes
    }

    task rebuild {
        group = 'build'
        description = 'Cleans build directory before running normal build task'

        dependsOn clean
        dependsOn build

        build.mustRunAfter clean
    }

    idea {
        module {
            jdkName = sourceCompatibility.isJava8Compatible() ? '1.8' : '9'
            setLanguageLevel(new IdeaLanguageLevel(jdkName))

            if(project.plugins.hasPlugin('kotlin-kapt')) {
                generatedSourceDirs += file("$project.buildDir/generated/source/kapt/")
            }
        }
    }
}

apply plugin: 'application'
apply plugin: 'com.github.johnrengelman.shadow'

mainClassName = 'xyz.laxus.Main'

dependencies {
    // Kotlin
    compile kotlinModule('stdlib-jdk8')
    compile kotlinModule('stdlib-jdk7')
    compile kotlinModule('reflect')
    compile kotlinModule("script-runtime")
    compile kotlinModule("script-util")
    runtime kotlinModule("compiler-embeddable")

    // Kotlin Coroutines
    compile kotlinxCoroutines('core')

    // Kotlin-JSON
    compile kotlinJson('jdk8')
    compile kotlinJson('reflect')
    compile kotlinJson('ktor-client')

    // JDA & Lavaplayer
    compile jda()
    compile jdaUtilities('commons')
    compile lavaplayer()

    // Database
    compile postgres()

    // Configuration
    compile hocon()

    // Logging
    compile slf4j()
    compile logback()

    // Requests
    compile okHttp()
    compile youtube()
    compile jsoup()

    // Ktor
    compile ktor('client-okhttp')
    compile ktor('client-core')
    compile ktor('client-json')

    // Misc
    compile jagtag()

    // Projects
    compile commons()
    compile commonsJda()
    compile database()
    compile core()
    compile coreMusic()
}

shadowJar {
    baseName = 'laxus'
    version = ''
    classifier = ''

    manifest {
        attributes 'Manifest-Version': "${ver.major}.${ver.minor}",
                   'Main-Class': mainClassName
    }
}

build {
    dependsOn classes
    dependsOn shadowJar

    shadowJar.mustRunAfter classes
}

idea {
    project {
        jdkName = sourceCompatibility.isJava8Compatible() ? '1.8' : '9'
        setLanguageLevel(new IdeaLanguageLevel(jdkName))
    }
}

wrapper {
    gradleVersion = '4.6'
}