build.gradle

import java.nio.file.FileSystems
import java.nio.file.Files

plugins {
    id "biz.aQute.bnd" version "6.1.0" apply false
}

allprojects {
    group = 'com.botts'
}

apply from: 'readmes.gradle'

if (!System.getenv("OSH_CORE_VERSION"))
    throw new Exception("OSH_CORE_VERSION not set")

ext {
    oshCoreVersion = System.getenv("OSH_CORE_VERSION")
}

description = 'NoCode Add-ons'

/* -----------------------------------------------------------
   BUNDLE HARVESTING + INDEX
----------------------------------------------------------- */

tasks.register("harvestBundles", Copy) {
    group = 'bundles'
    description = 'Collects OSGi bundle outputs from all subprojects'
    destinationDir = layout.buildDirectory.dir("osgi/bundles").get().asFile

    subprojects.each { subproj ->
        if (!subproj.name.contains("v4l")) {
            def osgiOutputs = subproj.osgi?.outputs
            if (osgiOutputs) from osgiOutputs
        }
    }
}

tasks.register("genOSGiIndex", aQute.bnd.gradle.Index) {
    group = 'bundles'
    dependsOn harvestBundles
    destinationDirectory = file(layout.buildDirectory.dir("osgi/bundles"))
    gzip = false
    bundles = fileTree(destinationDirectory) {
        include "**/*-bundle.jar"
        builtBy tasks.withType(Jar)
    }
}

tasks.register("bundlesDistZip", Zip) {
    group = 'bundles'
    dependsOn genOSGiIndex
    destinationDirectory = file(layout.buildDirectory.dir("osgi"))
    from layout.buildDirectory.dir("osgi/bundles")
    archiveFileName = "${rootProject.name}-osgi-bundles.zip"
}

tasks.register("cleanBundles") {
    group = 'bundles'
    doLast {
        delete layout.buildDirectory.dir("osgi")
    }
}

/* -----------------------------------------------------------
   SUBPROJECT CONFIG
----------------------------------------------------------- */

subprojects {

    apply plugin: 'java-library'
    apply plugin: 'java-test-fixtures'
    apply plugin: 'eclipse'
    apply plugin: 'maven-publish'

    if (project.findProperty("snapshot") == "true") {
        version = "${version}-SNAPSHOT"
    }
    ext.pom = {} // pom data that subprojects can append to

    // -----------------------------------------------------------
    // Prevent test fixtures from being published to Maven
    // -----------------------------------------------------------
    components.java.withVariantsFromConfiguration(
            configurations.testFixturesApiElements
    ) { skip() }

    components.java.withVariantsFromConfiguration(
            configurations.testFixturesRuntimeElements
    ) { skip() }

    sourceCompatibility = 17
    targetCompatibility = 17

    repositories {
        mavenCentral()

        maven {
            name = 'nexus'
            url = uri(System.getenv("NEXUS_REPO_URL"))
            credentials {
                username = System.getenv("NEXUS_ACTOR")
                password = System.getenv("NEXUS_TOKEN")
            }
        }
    }

    dependencies {
        testImplementation "junit:junit:4.13.1"
    }

    tasks.register("printVersion") {
        doLast {
            println("${project.name} version = ${project.version}")
        }
    }

    /* -----------------------------------------------------------
       EMBEDDED CONFIG MODEL
    ----------------------------------------------------------- */
    configurations {
        embeddedApi
        embeddedImpl
        embedded.extendsFrom(embeddedApi, embeddedImpl)
        api.extendsFrom(embeddedApi)
        implementation.extendsFrom(embeddedImpl)
    }

    /* -----------------------------------------------------------
       OSGI BUNDLE TASK
    ----------------------------------------------------------- */
    task osgi(type: aQute.bnd.gradle.Bundle) {
        from sourceSets.main.output
        archiveClassifier = 'bundle'

        bundle {
            classpath = sourceSets.main.compileClasspath
        }

        into('lib') {
            from configurations.embedded
        }

        // helper methods preserved exactly
        ext.getPackagesFromJar = { jarFile, packageSet ->
            FileSystems.newFileSystem(jarFile.toPath(), ClassLoader.getSystemClassLoader()).withCloseable { fs ->
                def rootDir = fs.getPath('/')
                getPackagesFromDir(rootDir, packageSet)
            }
        }

        ext.getPackagesFromDir = { rootDir, packageSet ->
            rootDir.eachDirRecurse { dir ->
                if (dir.toString().startsWith(File.separator + 'META-INF')) return

                Files.list(dir)
                        .filter { it.toString().endsWith('.class') }
                        .findAny()
                        .ifPresent {
                            def rel = rootDir.relativize(dir).toString()
                            packageSet.add(rel.replace('\\', '.').replace('/', '.') + '.*')
                        }
            }
        }

        ext.findActivator = {
            for (def classDir : sourceSets.main.output.classesDirs) {
                def rootDir = classDir.toPath()
                def activatorClass = Files.walk(rootDir)
                        .filter { it.toString().endsWith('Activator.class') }
                        .map {
                            rootDir.relativize(it).toString()
                                    .replace(File.separatorChar, (char) '.')
                                    .replaceAll('.class$', '')
                        }
                        .findAny()
                        .orElse(null)
                if (activatorClass) return activatorClass
            }
        }

        doFirst {
            manifest {
                attributes '-fixupmessages': 'Classes found in the wrong directory; is:=ignore,' +
                        'Unused Import-Package instructions; is:=ignore,' +
                        'The default package \'.\' is not permitted; is:=ignore,' +
                        'Unused Export-Package instructions; is:=ignore,'

                if (!attributes['-dsannotations'])
                    attributes '-dsannotations': '!*'

                if (!attributes['Bundle-Activator']) {
                    def activatorClass = findActivator()
                    if (activatorClass)
                        attributes 'Bundle-Activator': activatorClass
                }

                def embeddedJars = configurations.embedded
                def depJars = configurations.compileClasspath.minus(embeddedJars)
                def apiJars = configurations.embeddedApi

                def importedPackages = [] as Set
                depJars.each { getPackagesFromJar(it, importedPackages) }
                if (!attributes['Import-Package'])
                    attributes 'Import-Package': importedPackages.join(',')

                def exportedPackages = [] as Set
                sourceSets.main.output.classesDirs.each {
                    getPackagesFromDir(it.toPath(), exportedPackages)
                }
                apiJars.each { getPackagesFromJar(it, exportedPackages) }
                if (!attributes['-exportcontents'])
                    attributes '-exportcontents': exportedPackages.join(',')

                def runtimeDeps = configurations.runtimeClasspath.collect { it.name }
                def embeddedClasspath = ''
                configurations.embedded.each {
                    if (runtimeDeps.contains(it.name)) {
                        embeddedClasspath += "lib/${it.name},"
                    }
                }
                attributes 'Bundle-ClassPath': embeddedClasspath + '.'
                attributes 'OSH-Core-Version': oshCoreVersion
            }
        }
    }

    /* -----------------------------------------------------------
        BUILD MANIFESTS
    ----------------------------------------------------------- */
    afterEvaluate { p ->

        rootProject.dependencies {
            def dep = p.version.endsWith('SNAPSHOT') ? dev(p) : stable(p)
            dep.exclude group: 'org.sensorhub'
            dep.exclude group: 'org.vast.opengis'
        }

        if (p.name != "sensorhub-test") {

            p.osgi {
                manifest {
                    // main info
                    attributes 'Bundle-SymbolicName': p.group + '.' + p.name
                    if (p.description != null && !attributes['Bundle-Name'])
                        attributes 'Bundle-Name': p.description
                    if (p.details != null && !attributes['Bundle-Description'])
                        attributes 'Bundle-Description': p.details
                    attributes 'Bundle-Version': p.version
                    if (p.hasProperty('buildNumber') && p.buildNumber != null && !p.buildNumber.isEmpty())
                        attributes 'Bundle-BuildNumber': p.buildNumber
                    if (!attributes['Bundle-License'])
                        attributes 'Bundle-License': 'Proprietary – All rights reserved. No redistribution or modification permitted.'
                    if (!attributes['Bundle-Copyright'] && attributes['Bundle-Vendor'])
                        attributes 'Bundle-Copyright': 'Copyright (c) ' + attributes['Bundle-Vendor'] + '. All Rights Reserved'
                }
            }

            // also use osgi headers in JAR manifest
            p.jar {
                manifest {
                    from p.osgi.manifest
                    attributes 'OSH-Core-Version': oshCoreVersion
                }
            }
        }
    }

    /* -----------------------------------------------------------
       PUBLISHING (CLEAN + DEV FLAG SUPPORT)
    ----------------------------------------------------------- */

    publishing {
        publications {
            mavenJava(MavenPublication) {
                from components.java

                artifact(tasks.osgi) {
                    classifier = 'bundle'
                }

                pom {
                    name = project.description
                    description = project.hasProperty('details') && project.details ? project.details : project.description
                    url = 'https://georobotix.us'
                    licenses {
                        license {
                            name = 'Proprietary – All rights reserved'
                            url = 'https://georobotix.us/legal'
                            distribution = 'repo'
                        }
                    }
                    scm {
                        url = 'https://github.com/Botts-Innovative-Research/osh-no-code'
                        connection = 'scm:git:git://github.com/Botts-Innovative-Research/osh-no-code.git'
                    }
                    issueManagement {
                        url = 'https://github.com/Botts-Innovative-Research/osh-no-code/issues'
                        system = 'GitHub Issues'
                    }
                    properties.put("coreVersion", oshCoreVersion)
                }
            }
        }

        repositories {
            maven {
                name = "Nexus"

                if (project.version.toString().endsWith("SNAPSHOT")) {
                    url = System.getenv("NEXUS_REPO_SNAPSHOT")
                } else {
                    url = System.getenv("NEXUS_REPO_RELEASE")
                }

                credentials {
                    username = System.getenv("NEXUS_ACTOR")
                    password = System.getenv("NEXUS_TOKEN")
                }
            }
        }
    }

    /* -----------------------------------------------------------
       SAFETY CHECKS
    ----------------------------------------------------------- */

    tasks.named("generateMetadataFileForMavenJavaPublication") {
        doFirst {
            if (!System.getenv("NEXUS_ACTOR"))
                throw new Exception("NEXUS_ACTOR not set")

            if (!System.getenv("NEXUS_TOKEN"))
                throw new Exception("NEXUS_TOKEN not set")
        }
    }

    jar.dependsOn(copyReadmes)
    clean.dependsOn(cleanReadmes, cleanBundles)
}

/* -----------------------------------------------------------
   DISTRIBUTION CONFIGS
----------------------------------------------------------- */

configurations {
    stable
    dev
}