build.gradle

plugins {
    id "java"
    id "maven"
    id "signing"
    id "maven-publish"
    id 'org.cadixdev.licenser' version '0.5.0'
}

description = "Simple Neural Network Library"

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

license {
    exclude("**/*.bin")
    exclude("**/*.cu")
}

repositories {
    jcenter()
    maven { url "http://repo.maven.apache.org/maven2" }
}

def static getOsString() {
    String vendor = System.getProperty("java.vendor")
    if ("The Android Project" == vendor) {
        return "android"
    } else {
        String osName = System.getProperty("os.name")
        osName = osName.toLowerCase(Locale.ENGLISH)
        if (osName.startsWith("windows")) {
            return "windows"
        } else if (osName.startsWith("mac os")) {
            return "apple"
        } else if (osName.startsWith("linux")) {
            return "linux"
        } else if (osName.startsWith("sun")) {
            return "sun"
        }
        return "unknown"
    }
}

def static getArchString() {
    String osArch = System.getProperty("os.arch")
    osArch = osArch.toLowerCase(Locale.ENGLISH)
    if ("i386" == osArch || "x86" == osArch || "i686" == osArch) {
        return "x86"
    } else if (osArch.startsWith("amd64") || osArch.startsWith("x86_64")) {
        return "x86_64"
    } else if (osArch.startsWith("arm64")) {
        return "arm64"
    } else if (osArch.startsWith("arm")) {
        return "arm"
    } else if ("ppc" == osArch || "powerpc" == osArch) {
        return "ppc"
    } else if (osArch.startsWith("ppc")) {
        return "ppc_64"
    } else if (osArch.startsWith("sparc")) {
        return "sparc"
    } else if (osArch.startsWith("mips64")) {
        return "mips64"
    } else if (osArch.startsWith("mips")) {
        return "mips"
    } else if (osArch.contains("risc")) {
        return "risc"
    }
    return "unknown"
}


def addJCudaDependecies(List<String> deps) {
    def classifier = getOsString() + "-" + getArchString()
    dependencies {
        deps.each {
            compile(group: 'org.jcuda', name: it, version: project.jcuda_version) {
                transitive = false
            }
            compileOnly group: 'org.jcuda', name: "${it}-natives", classifier: classifier, version: project.jcuda_version
        }
    }
}

dependencies {
    testCompile "org.processing:core:${project.processing_version}"

    addJCudaDependecies(["jcuda", "jcurand"])
}

task examplesJar(type: Jar) {
    classifier "examples"
    dependsOn(jar)
    from sourceSets.test.compileClasspath
}

task examplesSourceJar(type: Jar) {
    classifier "examples-sources"
    dependsOn(jar)
    from sourceSets.test.allSource
}

task runJCuda(type: JavaExec) {
    dependsOn(examplesJar)
    classpath = sourceSets.test.runtimeClasspath
    mainClass = "com.oroarmor.neural_network.numberID.NumberIDJCuda"
}

task sourceJar(type: Jar) {
    classifier "sources"
    from sourceSets.main.allJava
}

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

artifacts {
    archives jar, sourceJar, javadocJar, examplesJar, examplesSourceJar
}

signing {
    useGpgCmd()
    sign configurations.archives
}

group = project.maven_group
archivesBaseName = project.archives_base_name
version = project.version

uploadArchives {
    repositories {
        mavenDeployer {
            def ossrhUsername = "OroArmor"
            def ossrhPassword = project.hasProperty("ossrhPassword") ? project.property("ossrhPassword") : System.getenv("OSSRH_PASSWORD")

            beforeDeployment {
                MavenDeployment deployment -> signing.signPom(deployment)
            }

            repository(url: "https://oss.sonatype.org/service/local/staging/deploy/maven2/") {
                authentication(userName: ossrhUsername, password: ossrhPassword)
            }

            snapshotRepository(url: "https://oss.sonatype.org/content/repositories/snapshots/") {
                authentication(userName: ossrhUsername, password: ossrhPassword)
            }
            pom.project {
                name 'Neural Network Library'
                packaging 'jar'
                // optionally artifactId can be defined here
                description 'A simple Java Neural Network Library'
                url 'http://github.com/OroArmor/NeuralNetwork'

                scm {
                    connection 'scm:git:git://github.com/OroArmor/NeuralNetwork.git'
                    developerConnection 'scm:git:ssh://github.com:OroArmor/NeuralNetwork.git'
                    url 'http://github.com/OroArmor/NeuralNetwork'
                }

                licenses {
                    license {
                        name 'MIT License'
                        url 'https://mit-license.org/'
                    }
                }

                developers {
                    developer {
                        id 'OroArmor'
                        name 'Eli Orona'
                        email 'eliorona@live.com'
                        url "oroarmor.com"
                    }
                }
            }
        }
    }
}