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.
 */
buildscript {
    ext {
        kotlin_version = '1.2.51'
        ktor_version = '0.9.3'
        dokka_version = '0.9.17'
        junit_version = '1.0.1'
        jupiter_version = '5.0.1'
        node_plugin_version = '1.2.0'
        shadow_version = '2.0.1'
        versions_version = '0.17.0'
        bintray_version = '1.7.3'
    }

    repositories {
        jcenter()
        maven { url = "https://plugins.gradle.org/m2/" }
    }
    
    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
        classpath "org.jetbrains.dokka:dokka-gradle-plugin:$dokka_version"
        classpath "org.junit.platform:junit-platform-gradle-plugin:$junit_version"
        classpath "com.github.jengelman.gradle.plugins:shadow:$shadow_version"
        classpath "com.moowork.gradle:gradle-node-plugin:$node_plugin_version"
        classpath "com.github.ben-manes:gradle-versions-plugin:$versions_version"
        classpath "com.jfrog.bintray.gradle:gradle-bintray-plugin:$bintray_version"
    }
}

def versionObj = [major: 1, minor: 7, revision: 2]

allprojects {
    apply plugin: 'idea'
    apply plugin: 'maven-publish'
    apply plugin: 'com.jfrog.bintray'

    group = 'me.kgustave'
    version = versionObj.values().join('.')

    rootProject.subprojects.each { p ->
        if(p != rootProject) {
            String functionName = p.name.split('-').collect { it.capitalize() }.join('').uncapitalize()
            project.ext."$functionName" = { p }
        }
    }

    bintray {
        def keysFile = rootProject.file("keys/keys.properties")
        if(keysFile.exists()) {
            def keys = new Properties()
            keysFile.withReader { keys.load(it) }
            user = keys['bintray.user.name']
            key = keys['bintray.api.key']
        }

        publications = ['BintrayRelease']
        publish = true

        pkg {
            repo = 'maven'
            name = 'kotlin-json'
            licenses = ['Apache-2.0']
            vcsUrl = 'https://github.com/Shengaero/kotlin-json.git'
            githubRepo = 'https://github.com/Shengaero/kotlin-json/'
            version {
                name = project.version
                released = new Date()
            }
        }
    }
}

subprojects {
    // Deprecated modules are fully configured individually
    //in order to maintain backwards compatibility.
    if(project.hasProperty('deprecated') && project.deprecated) return

    apply plugin: 'java-library'
    apply plugin: 'com.github.ben-manes.versions'

    ext {
        moduleName = "$rootProject.name-$project.name"
        useExperimental = { String exp -> "-Xuse-experimental=$exp" }

        repositories {
            ktorBintray = {
                maven { url = "https://dl.bintray.com/kotlin/ktor" }
            }
        }

        dependencies {
            kotlin = { String module -> "org.jetbrains.kotlin:kotlin-$module:$kotlin_version" }
            ktor = { String module -> "io.ktor:ktor-$module:$ktor_version" }
            junit = { String module -> "org.junit.jupiter:junit-jupiter-$module:$jupiter_version" }
        }
    }

    apply from: "$rootProject.projectDir/config/kotlin-common.gradle"
    apply from: "$rootProject.projectDir/config/kotlin-jvm.gradle"
    apply from: "$rootProject.projectDir/config/kotlin2js.gradle"
    apply from: "$rootProject.projectDir/config/dokka.gradle"

    setProperty('archivesBaseName', moduleName)

    repositories {
        jcenter()
    }

    jar {
        baseName = "$moduleName"
        version = "$version"
        classifier = ''
        manifest {
            attributes 'Automatic-Module-Name': "kotlin.json.$project.name",
                       'Implementation-Version': "$version",
                       'Implementation-Title': "$moduleName"
        }
    }

    task sourcesJar(type: Jar) {
        group = 'build'
        description = 'Generates a sources jar'

        baseName = "$moduleName"
        version = "$project.version"
        classifier = 'sources'
        from { sourceSets.main.allSource }
    }

    build {
        dependsOn clean
        dependsOn jar
        dependsOn sourcesJar

        jar.mustRunAfter clean
        sourcesJar.mustRunAfter jar
    }

    publishing {
        publications {
            BintrayRelease(MavenPublication) {
                groupId = project.group
                artifactId = moduleName
                version = project.version

                from project.components.java
                if(!project.getTasksByName('dokkaJar', false).isEmpty()) {
                    artifact project.tasks.dokkaJar
                }
                artifact project.tasks.sourcesJar

                pom.withXml {
                    def repositoriesNode = asNode().appendNode('repositories')
                    def repositoryNode = repositoriesNode.appendNode('repository')

                    repositoryNode.appendNode('name', 'bintray')
                    repositoryNode.appendNode('id', 'bintray-kgustave-maven')
                    repositoryNode.appendNode('url', 'https://dl.bintray.com/kgustave/maven')

                    def dependingModules = configurations.compile.filter { it instanceof ProjectDependency }
                    if(dependingModules.size() > 0) {
                        def dependenciesNode = asNode().appendNode('dependencies')
                        dependingModules.each {
                            def dependencyNode = dependenciesNode.appendNode('dependency')
                            dependencyNode.appendNode('groupId', it.group)
                            dependencyNode.appendNode('artifactId', it.dependencyProject.moduleName)
                            dependencyNode.appendNode('version', it.version)
                            dependencyNode.appendNode('scope', 'compile')
                        }
                    }
                }
            }
        }
    }
}

wrapper {
    gradleVersion = '4.6'
}

task uploadAll {
    group = 'publishing'
    description = 'Publishes all modules.'

    rootProject.childProjects.values().each {
        it.getTasksByName('bintrayUpload', true).each {
            dependsOn it
        }
    }
    dependsOn bintrayUpload
}

publishing {
    publications {
        BintrayRelease(MavenPublication) {
            groupId = project.group
            artifactId = 'kotlin-json'
            version = project.version
            pom.withXml {
                def repositoriesNode = asNode().appendNode('repositories')
                def repositoryNode = repositoriesNode.appendNode('repository')

                repositoryNode.appendNode('name', 'bintray')
                repositoryNode.appendNode('id', 'bintray-kgustave-maven')
                repositoryNode.appendNode('url', 'https://dl.bintray.com/kgustave/maven')

                def dependenciesNode = asNode().appendNode('dependencies')
                def dependencyNode = dependenciesNode.appendNode('dependency')
                def core = jdk8()

                dependencyNode.appendNode('groupId', core.group)
                dependencyNode.appendNode('artifactId', core.moduleName)
                dependencyNode.appendNode('version', core.version)
                dependencyNode.appendNode('scope', 'compile')
            }
        }
    }
}