build.gradle

import org.w3c.dom.Element
import org.w3c.dom.Node
import org.w3c.dom.NodeList

//We need this in the parent project since it else not discovered by the subprojects.
buildscript {
    repositories {
        jcenter()
        maven { url = "https://files.minecraftforge.net/maven" }
        mavenLocal()
        maven {
            url 'http://dogforce-games.com/maven'
        }
    }
    dependencies {
        classpath group: 'net.minecraftforge.gradle', name: 'ForgeGradle', version: '3.+', changing: true
        //classpath group: 'net.minecraftforge.gradle', name: 'ForgeGradle', version: '3.0.161-read-gradle-delegation', changing: true
        classpath "org.jfrog.buildinfo:build-info-extractor-gradle:latest.release"
    }
}

//Setup a property to hold all leaf projects.
//Aka projects that are here only for organizational structure need to get eliminated
//From configuration.
ext {
    leafProjects = new HashSet<Project>()
}

//Collect all leaf projects into a property to use.
project.allprojects(new Action<Project>() {
    @Override
    void execute(final Project candidate) {
        if (candidate.getChildProjects().isEmpty())
            leafProjects.add(candidate)
    }
})

def globalAT = file('main/src/main/resources/META-INF/accesstransformer.cfg');

//We only configure the leaf projects. We do not care about the root project or any inbetween project.
configure(leafProjects) {projectToConfigure ->
    projectToConfigure.logger.lifecycle("Setting up project: " + projectToConfigure.getPath() + " as leaf project.")
    
    //Add the central repository so that we always have access to our cached dependencies.
    repositories {
        maven {
            name 'LDTTeam - Modding'
            url 'https://ldtteam.jfrog.io/ldtteam/modding/'
        }
    }
    
    //We want a unique project identifier based on the projects full name.
    //Get the projects path (:projectRoot:projectTwo)
    //Strip the initial :
    //Replace all remaining : with -
    ext {
        projectIdentifier = projectToConfigure.getPath().substring(1).replace(":", "-")
    }
    
    //Setup the plugins that we need.
    apply plugin: 'net.minecraftforge.gradle'
    apply plugin: 'idea'
    apply plugin: 'eclipse'
    apply plugin: 'java'
    apply plugin: 'java-library'
    apply plugin: 'maven-publish'
    apply plugin: 'com.jfrog.artifactory'
    
    //Setup group, version and basename.
    group = "com.ldtteam.blockout"
    version = System.getenv().containsKey("Version") ? System.getenv("Version") : "borked-" + System.currentTimeMillis()
    archivesBaseName = "blockout-$projectIdentifier"

    //Force minecraft compatible versions of dependencies
    configurations.all {
        resolutionStrategy {
            force 'com.google.guava:guava:21.0'
        }
    }

    minecraft {
        mappings channel: mappings_channel, version: mappings_version
        accessTransformer = globalAT
    }

    //All projects should be able to shade artifacts into them selfs.
    configurations {
        shade {
            transitive = false
        }
        shadeTransitive {
            transitive = true
        }

        shadeRuntime {
            transitive = false
        }
        shadeRuntimeTransitive {
            transitive = true
        }

        shadeTransitive.extendsFrom shade
        shadeRuntimeTransitive.extendsFrom shadeRuntime

        api.extendsFrom shadeTransitive
        runtimeOnly.extendsFrom shadeRuntimeTransitive
    }

    //All mods have the same test harness.
    //JUNIT, MOCKITO, POWERMOCK and HAMCREST are being added here.
    dependencies {
        minecraft "net.minecraftforge:forge:${minecraft_version}-${forge_version}"

        api 'com.intellij:annotations:+@jar'
        
        testImplementation 'junit:junit:4.11'
        testImplementation "org.mockito:mockito-core:1.+"
        testImplementation group: 'org.powermock', name: 'powermock-module-junit4', version: '1.6.5'
        testImplementation group: 'org.powermock', name: 'powermock-api-mockito', version: '1.6.5'
        testImplementation group: 'org.hamcrest', name: 'hamcrest-all', version: '1.3'
        testImplementation group: 'pl.pragmatists', name:'JUnitParams', version: '1.1.1'
    }

    projectToConfigure.afterEvaluate {projectToConfigureAfterEvaluate ->
        jar {
            //noinspection GroovyAssignabilityCheck
            from (projectToConfigureAfterEvaluate.configurations.shade.files) {
                include '*'
                into 'META-INF/libraries'
            }

            //noinspection GroovyAssignabilityCheck
            from (projectToConfigureAfterEvaluate.configurations.shadeRuntime.files) {
                include '*'
                into 'META-INF/libraries'
            }

            def containedDeps = projectToConfigureAfterEvaluate.configurations.shade.files.collect { it.name }.join(' ')
            if (!projectToConfigureAfterEvaluate.configurations.shadeRuntime.files.isEmpty())
            {
                containedDeps = containedDeps + ' ' + projectToConfigureAfterEvaluate.configurations.shadeRuntime.files.collect { it.name }.join(' ')
            }

            manifest {
                attributes([
                        'ContainedDeps': containedDeps,
                        'Maven-Artifact': "${projectToConfigureAfterEvaluate.group}:${projectToConfigureAfterEvaluate.archivesBaseName}:${projectToConfigureAfterEvaluate.version}",
                        'Timestamp': System.currentTimeMillis(),
                ])
            }
        }
    }
    
    //Setup for which java version we are compiling
    //Minecraft defaults to 1.8, anything higher does currently not work with Forge.
    sourceCompatibility = targetCompatibility = '1.8' // Need this here so eclipse task generates correctly.
    compileJava {
        sourceCompatibility = targetCompatibility = '1.8'
    }
    
    //Setup the compiler to output all information we need.
    compileJava {
        options.encoding = 'UTF-8'
        options.compilerArgs << "-Xlint"
    }

    //Create a sources jar.
    task sourcesJar(type: Jar) {
        classifier = 'sources'
        from sourceSets.main.allSource
    }

    //Create a javadoc jar.
    task javadocJar(type: Jar, dependsOn: javadoc) {
        classifier = 'javadoc'
        from javadoc.destinationDir
    }

    //Define what to publish and how.
    publishing {
        publications {
            maven(MavenPublication) {
                groupId = project.group
                artifactId "blockout-$projectIdentifier"

                from components.java
                artifact javadocJar
                artifact sourcesJar

                pom {
                    url = 'https://github.com/ldtteam/BlockOut'
                    licenses {
                        license {
                            name = 'GNU GENERAL PUBLIC LICENSE Version 3'
                            url = 'https://www.gnu.org/licenses/gpl-3.0.en.html'
                        }
                    }
                    developers {
                        developer {
                            id = 'OrionDevelopment'
                            name = 'Marc Hermans'
                            email = 'oriondevelopment@outlook.com'
                        }
                    }
                    contributors {
                        contributor {
                            id = 'ldtteam'
                            name = 'Let\'s Develop Together - Team'
                            email = 'info@ldtteam.com'
                        }
                    }
                    scm {
                        connection = 'scm:git:git://github.com/ldtteam/blockout.git'
                        developerConnection = 'scm:git:ssh://github.com/ldtteam/blockout.git'
                        url = 'https://github.com/ldtteam/BlockOut'
                    }
                }

                //Replace all deobf dependencies with normal jar references.
                pom.withXml { xmlProvider ->
                    final Element document = xmlProvider.asElement()

                    //Remove all deobf deps.
                    final NodeList groupIdNodes = document.getElementsByTagName("groupId")
                    groupIdNodes.each { groupIdNodeObject ->
                        final Node groupIdNode = (Node) groupIdNodeObject
                        final String groupId = groupIdNode.getFirstChild().getTextContent().trim()
                        groupIdNode.setTextContent(groupId.replace("deobf.", ""))
                    }

                    //Remove MC Forge.
                    final NodeList dependencies = document.getElementsByTagName("dependency")
                    final List<Node> dependencyCache = new ArrayList<>();
                    dependencies.each { dep -> dependencyCache.add(dep) }

                    dependencyCache.each {dependencyNode ->
                        final Element dependencyElement = (Element) dependencyNode;

                        final NodeList groupIdNodesInDependency = dependencyElement.getElementsByTagName("groupId")
                        groupIdNodesInDependency.each {groupIdNodeInDep ->
                            final String groupId = groupIdNodeInDep.getFirstChild().getTextContent().trim();
                            if (groupId == "net.minecraftforge")
                            {
                                final NodeList artifactIdNodesInDependency = dependencyElement.getElementsByTagName("artifactId")
                                artifactIdNodesInDependency.each { artifactIdNodeInDep ->
                                    final String artifactId = artifactIdNodeInDep.getFirstChild().getTextContent().trim();
                                    if (artifactId == "forge")
                                    {
                                        dependencyNode.getParentNode().removeChild(dependencyNode);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    //Notify artifactory of what to publish.
    artifactory {
        publish {
            defaults {
                publications('maven', 'library', 'full', 'minimal')
                publishBuildInfo = true   //Publish build-info to Artifactory (true by default)
                publishArtifacts = true   //Publish artifacts to Artifactory (true by default)
                publishPom = true   //Publish generated POM files to Artifactory (true by default).
            }
        }
    }
}

//Configure the root project for publishing.
project.configure([project]) { rootProject ->
    //Setup the plugins that we need.
    apply plugin: 'maven-publish'
    apply plugin: 'com.jfrog.artifactory'

    //Setup group, version and basename.
    group = "com.ldtteam.blockout"
    version = System.getenv().containsKey("Version") ? System.getenv("Version") : "borked-" + System.currentTimeMillis()

    configurations {
        minimalImplementation {
            transitive = false
        }
        minimalRuntime {
            transitive = false
        }

        fullImplementation {
            transitive = false
        }
        fullRuntime {
            transitive = false
        }

        fullImplementation.extendsFrom minimalImplementation
        fullRuntime.extendsFrom minimalRuntime
    }

    dependencies {
        minimalImplementation project(':api')
        fullImplementation project(':controls:concepts')
        fullImplementation project(':controls:implementations')
        fullImplementation project(':utils:helpers')

        minimalRuntime project(':main')
        fullRuntime project(':lang:json')
        fullRuntime project(':lang:xml')
    }

    rootProject.afterEvaluate { rootProjectAfterEvaluate ->
        //Define what to publish and how.
        publishing {
            publications {
                maven(MavenPublication) {
                    artifactId "blockout"

                    pom {
                        url = 'https://github.com/ldtteam/BlockOut'
                        licenses {
                            license {
                                name = 'GNU GENERAL PUBLIC LICENSE Version 3'
                                url = 'https://www.gnu.org/licenses/gpl-3.0.en.html'
                            }
                        }
                        developers {
                            developer {
                                id = 'OrionDevelopment'
                                name = 'Marc Hermans'
                                email = 'oriondevelopment@outlook.com'
                            }
                        }
                        contributors {
                            contributor {
                                id = 'ldtteam'
                                name = 'Let\'s Develop Together - Team'
                                email = 'info@ldtteam.com'
                            }
                        }
                        scm {
                            connection = 'scm:git:git://github.com/ldtteam/blockout.git'
                            developerConnection = 'scm:git:ssh://github.com/ldtteam/blockout.git'
                            url = 'https://github.com/ldtteam/BlockOut'
                        }
                    }
                }

                full(MavenPublication) {
                    artifactId "blockout-platform-full"

                    pom {
                        url = 'https://github.com/ldtteam/BlockOut'
                        licenses {
                            license {
                                name = 'GNU GENERAL PUBLIC LICENSE Version 3'
                                url = 'https://www.gnu.org/licenses/gpl-3.0.en.html'
                            }
                        }
                        developers {
                            developer {
                                id = 'OrionDevelopment'
                                name = 'Marc Hermans'
                                email = 'oriondevelopment@outlook.com'
                            }
                        }
                        contributors {
                            contributor {
                                id = 'ldtteam'
                                name = 'Let\'s Develop Together - Team'
                                email = 'info@ldtteam.com'
                            }
                        }
                        scm {
                            connection = 'scm:git:git://github.com/ldtteam/blockout.git'
                            developerConnection = 'scm:git:ssh://github.com/ldtteam/blockout.git'
                            url = 'https://github.com/ldtteam/BlockOut'
                        }
                    }

                    pom.withXml {xml ->
                        def dependenciesNode = xml.asNode().appendNode('dependencies')

                        rootProjectAfterEvaluate.configurations.fullImplementation.allDependencies.stream()
                                .each {
                                    def dependencyNode = dependenciesNode.appendNode('dependency')
                                    dependencyNode.appendNode('groupId', it.group)

                                    if (it instanceof ProjectDependency)
                                    {
                                        def depProj = it.getDependencyProject();
                                        dependencyNode.appendNode('artifactId', "blockout-$depProj.projectIdentifier")
                                    }
                                    else
                                    {
                                        dependencyNode.appendNode('artifactId', it.name)
                                    }
                                    dependencyNode.appendNode('version', it.version)
                                    dependencyNode.appendNode('scope', 'compile')
                                }

                        rootProjectAfterEvaluate.configurations.fullRuntime.allDependencies.stream()
                                .each {
                                    def dependencyNode = dependenciesNode.appendNode('dependency')
                                    dependencyNode.appendNode('groupId', it.group)

                                    if (it instanceof ProjectDependency)
                                    {
                                        def depProj = it.getDependencyProject();
                                        dependencyNode.appendNode('artifactId', "blockout-$depProj.projectIdentifier")
                                    }
                                    else
                                    {
                                        dependencyNode.appendNode('artifactId', it.name)
                                    }
                                    dependencyNode.appendNode('version', it.version)
                                    dependencyNode.appendNode('scope', 'runtime')
                                }
                    }
                }

                minimal(MavenPublication) {
                    artifactId "blockout-platform-minimal"

                    pom {
                        url = 'https://github.com/ldtteam/BlockOut'
                        licenses {
                            license {
                                name = 'GNU GENERAL PUBLIC LICENSE Version 3'
                                url = 'https://www.gnu.org/licenses/gpl-3.0.en.html'
                            }
                        }
                        developers {
                            developer {
                                id = 'OrionDevelopment'
                                name = 'Marc Hermans'
                                email = 'oriondevelopment@outlook.com'
                            }
                        }
                        contributors {
                            contributor {
                                id = 'ldtteam'
                                name = 'Let\'s Develop Together - Team'
                                email = 'info@ldtteam.com'
                            }
                        }
                        scm {
                            connection = 'scm:git:git://github.com/ldtteam/blockout.git'
                            developerConnection = 'scm:git:ssh://github.com/ldtteam/blockout.git'
                            url = 'https://github.com/ldtteam/BlockOut'
                        }
                    }

                    pom.withXml {xml ->
                        def dependenciesNode = xml.asNode().appendNode('dependencies')

                        rootProjectAfterEvaluate.configurations.minimalImplementation.allDependencies.stream()
                                .each {
                                    def dependencyNode = dependenciesNode.appendNode('dependency')
                                    dependencyNode.appendNode('groupId', it.group)

                                    if (it instanceof ProjectDependency)
                                    {
                                        def depProj = it.getDependencyProject();
                                        dependencyNode.appendNode('artifactId', "blockout-$depProj.projectIdentifier")
                                    }
                                    else
                                    {
                                        dependencyNode.appendNode('artifactId', it.name)
                                    }
                                    dependencyNode.appendNode('version', it.version)
                                    dependencyNode.appendNode('scope', 'compile')
                                }

                        rootProjectAfterEvaluate.configurations.minimalRuntime.allDependencies.stream()
                                .each {
                                    def dependencyNode = dependenciesNode.appendNode('dependency')
                                    dependencyNode.appendNode('groupId', it.group)

                                    if (it instanceof ProjectDependency)
                                    {
                                        def depProj = it.getDependencyProject();
                                        dependencyNode.appendNode('artifactId', "blockout-$depProj.projectIdentifier")
                                    }
                                    else
                                    {
                                        dependencyNode.appendNode('artifactId', it.name)
                                    }
                                    dependencyNode.appendNode('version', it.version)
                                    dependencyNode.appendNode('scope', 'runtime')
                                }
                    }
                }
            }
        }

        //Notify artifactory of what to publish.
        artifactory {
            publish {
                defaults {
                    publications('maven', 'library', 'full', 'minimal')
                    publishBuildInfo = true   //Publish build-info to Artifactory (true by default)
                    publishArtifacts = true   //Publish artifacts to Artifactory (true by default)
                    publishPom = true   //Publish generated POM files to Artifactory (true by default).
                }
            }
        }
    }
}

task setupCIWorkspace {
    doLast {
        println "Finished setup."
    }
}

task curseforge {
    doLast {
        println "Upload to CF not available yet."
    }
}

task("createChangelog") {
    group = 'upload'

    doLast {
        def teamCityURL = "https://teamcity.minecolonies.com/"
        (new File("./build")).mkdirs()
        def file = new FileOutputStream("build/changelog.md")
        def out = new BufferedOutputStream(file)
        def changesXML = new XmlSlurper().parse(teamCityURL + "guestAuth/app/rest/changes?locator=build:(id:" + teamcity["teamcity.build.id"] + ")")

        def changes = changesXML.change
        println("createChangelog: Identified " + changes.size() + " changes to be written into the changelog.")

        out << "# BlockOut Changelog \n"
        out << "## Version: _" + version + "_ \n"

        if (changes.size() > 0) {
            for (int i = 0; i < changes.size(); i++) {
                def changeDetailsURL = teamCityURL + "guestAuth/app/rest/changes/id:" + changes[i].@id.text()
                def changeDetailsXml = new XmlSlurper().parse(changeDetailsURL)
                def changeComment = changeDetailsXml.comment.text().trim()

                out << "* " + changeComment + "\n"
            }
        } else {
            out << "No Changes detected!"
        }

        out.close()
    }
}