build.gradle

plugins {
    id "com.gorylenko.gradle-git-properties" version "2.4.2"
}

description = "An IMC Java with bindings and generator for IMC."

defaultTasks 'dist', 'libsender'

ext {
    distFolderName = "dist"
    toolsFolderName = "tools"

    automaticModuleNameBase = "pt.lsts.imc"
}

allprojects {
    version = '5.90.4'
    repositories {
        mavenCentral()
    }

    apply plugin: 'java'
    compileJava.options.encoding = 'UTF-8'
    
    apply plugin: "com.gorylenko.gradle-git-properties"
    
    sourceSets {
        main {
            java {
                srcDirs = ['java']
            }
            resources {
                srcDirs = ['resources']
            }
        }
    }

    processResources {
        from (rootProject.projectDir) {
            include 'COPYRIGHT.TXT'
        }
        doLast {
            println 'Added common resources'
        }
    }

    jar {
        manifest {
            attributes( 'Specification-Title': rootProject.name
                    ,'Specification-Version': project.version
                    ,'Implementation-Title': project.name
                    ,'Implementation-Version': project.version
                    ,'Build-Revision': "${rootProject.name}-${project.version}-git#${-> project.ext.gitProps['git.commit.id.describe']}"
                    ,'Automatic-Module-Name': "${rootProject.ext.automaticModuleNameBase}.${project.name}"
                    ,'Build-Jdk': System.properties['java.version']
                    )
        }
    }

    gitProperties {
        extProperty = 'gitProps'
        failOnNoGitDirectory = false

        dateFormat = "yyyy-MM-dd'T'HH:mmZ"
        dateFormatTimeZone = "UTC"

        gitPropertiesName = "git.info"
        keys = ['git.branch',
                'git.build.version',
                'git.closest.tag.commit.count',
                'git.closest.tag.name',
                'git.commit.id',
                'git.commit.id.abbrev',
                'git.commit.id.describe',
                'git.commit.time',
                'git.dirty',
                'git.remote.origin.url',
                'git.tags',
                ]
    }
    generateGitProperties.outputs.upToDateWhen { false }

}

configure(subprojects.findAll { it.name != 'core' }) {
    dependencies {
        implementation project(':core')
        implementation project(':core').sourceSets.main.runtimeClasspath
    }

    java {
        sourceCompatibility = JavaVersion.VERSION_1_8
        targetCompatibility = JavaVersion.VERSION_1_8
    }
}

/**
 * To add a net task to a project.
 * @param proj the project object
 * @param taskName the name of the task
 * @param jarBaseName the archiveBaseName, use null for using the taskName instead
 * @param destFolder the destination folder (relative to root folder, use null to use default
 * @param mainClass the main class to add to the manifest, use null for none
 * @param otherProjectsToPackToDistList other projects to add
 * @param excludeCore to exclude adding the core libraries, you will needthem at runtime in the classpath
 *
 */
def jarTask(proj, taskName, jarBaseName, destFolder, mainClass, otherProjectsToPackToDistList, excludeCore) {
    configure(proj) {
        proj.tasks.create(taskName, Jar) {
            // Must be a better way to get the core jar here and filter out of the classpath for jar creation
            dependsOn project(":core").getTasksByName("dist", true)

            if (otherProjectsToPackToDistList != null)
                dependsOn otherProjectsToPackToDistList.collect { it.jar }
            duplicatesStrategy = DuplicatesStrategy.EXCLUDE
            description = "Generate ${jarBaseName ?: taskName} for IMC API"
            group = 'Distribution'
            manifest {m ->
                m.getAttributes().put 'Specification-Title', rootProject.name
                if (mainClass != null && !mainClass.isEmpty())
                    m.getAttributes().put 'Main-Class', mainClass
                m.getAttributes().put 'Specification-Version', project.version
                m.getAttributes().put 'Implementation-Title', "$project.name, ${jarBaseName ?: taskName}"
                m.getAttributes().put 'Implementation-Version', project.version
                m.getAttributes().put 'Build-Revision', "${rootProject.name}-${project.version}-git#${-> project.ext.gitProps['git.commit.id.describe']}"
                m.getAttributes().put 'Automatic-Module-Name', "${rootProject.ext.automaticModuleNameBase}.$taskName"
                m.getAttributes().put 'Build-Jdk', System.properties['java.version']
            }

            // Adding runtime jars into the jar
            def addedAssets = configurations.runtimeClasspath - configurations.runtimeClasspath
            if (otherProjectsToPackToDistList != null) {
                otherProjectsToPackToDistList.collect { addedAssets += (it.sourceSets.main.runtimeClasspath - configurations.runtimeClasspath) }
                addedAssets = addedAssets.findAll { !it.toString().contains(project.buildDir.toString()) }
            }

            // Adding runtime jars into the jar
            def coreConf = configurations.runtimeClasspath - project(':core').sourceSets.main.runtimeClasspath
            coreConf = coreConf.filter { File file ->
                file.absolutePath ==~ "${project(':core').jar.archiveFile.get().getAsFile().getAbsolutePath().replaceAll('\\\\', '\\\\\\\\')}" ? false : true
            }
            from { coreConf.collect { it.isDirectory() ? it : zipTree(it).matching {
                exclude "module-info.class"
            } } }
            if (!addedAssets.isEmpty())
                from { addedAssets.toUnique().collect { it.isDirectory() ? it : zipTree(it).matching {
                    exclude "module-info.class"
                } } }
            if (excludeCore != null && !excludeCore)
                from { zipTree(project(':core').dist.archivePath) }
            with jar
            archiveBaseName = jarBaseName ?: taskName
            //archiveVersion = ''
            destinationDirectory = file(destFolder != null && !destFolder.isEmpty() ? "$rootDir/$destFolder" : "$rootDir/$distFolderName")

            doLast {
                // println "$project.name"
                // println project(':core').dist.archivePath
                // println project(':core').jar.archivePath
                // project(':core').sourceSets.main.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) }.each { print ' >> '; println it }
                // project(':core').configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) }.each { print ' |> '; println it }
                // println "configurations.runtimeClasspath"

                // coreConf.collect { it.isDirectory() ? it : zipTree(it) }.each { print ' > '; println it }

                // println "addedAssets"
                // if (!addedAssets.isEmpty())
                //     addedAssets.toUnique().collect { it.isDirectory() ? it : zipTree(it) }.each { print ' > '; println it }
            }
        }
    }
}

clean {
    delete fileTree(dir: "$distFolderName" , include: '**/*.jar')
}

task cleanEclipseFiles {
    delete fileTree(dir: "$rootDir" , include: '**/.project')
    delete fileTree(dir: "$rootDir" , include: '**/.classpath')
    delete fileTree(dir: "$rootDir" , include: '**/.settings')
}

task cleanIdeaFiles {
    delete fileTree(dir: "$rootDir" , include: '**/.idea')
}

task cleanVSCodeFiles {
    delete fileTree(dir: "$rootDir" , include: '.vscode')
}