build.gradle

plugins {
    id 'com.github.johnrengelman.shadow' version '2.0.2'
}

ext {
   apiProject = false
}

allprojects {
    apply plugin: 'java'
    apply plugin: 'maven'
    apply plugin: 'signing'
    apply plugin: 'eclipse'
    apply plugin: 'idea'

    // force source/target compatibility
    tasks.withType(JavaCompile) {
        sourceCompatibility = rootProject.sourceCompatibility
        targetCompatibility = rootProject.targetCompatibility
    }

    // apply vrl license header plugin
//    if (!project.plugins.findPlugin(eu.mihosoft.vrl.vlicenseheaderutil.gradle.VLicenseHeaderPlugin)) {
//        project.apply(plugin: eu.mihosoft.vrl.vlicenseheaderutil.gradle.VLicenseHeaderPlugin)
//    }
//    // license template (will be used as header in all Java source files)
//    repairHeaders.licenseHeaderText = new File(projectDir,"../license-template.txt")

    repositories {
        mavenLocal()
        mavenCentral()
        jcenter()
        maven { 
            url 'https://oss.sonatype.org/content/repositories/snapshots/'
        }
        maven { 
            url 'http://oss.sonatype.org/content/repositories/releases/'
        }
    }

    signing {
        sign configurations.archives
    }

    signArchives.onlyIf {
        project.hasProperty('sonatypeUsername') && project.hasProperty('sonatypePassword')
    }

    uploadArchives.onlyIf {
        project.hasProperty('sonatypeUsername') && project.hasProperty('sonatypePassword')
    }

    uploadArchives {
        if (!project.hasProperty('sonatypeUsername') || !project.hasProperty('sonatypePassword')) {
            return
        }

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

            repository(url: 'https://oss.sonatype.org/service/local/staging/deploy/maven2') {
                authentication(userName: sonatypeUsername, password: sonatypePassword)
            }

            snapshotRepository(url: 'https://oss.sonatype.org/content/repositories/snapshots') {
                authentication(userName: sonatypeUsername, password: sonatypePassword)
            }

            pom.project {
                artifactId   "${project.name}"
                name         "${project.name}"
                url          'http://jfxtras.org'
                description  'Miscellaneous components for JavaFX'
                packaging    'jar'
                licenses {
                    license {
                        name 'BSD'
                        url 'http://www.opensource.org/licenses/bsd-license.php'
                        distribution 'repo'
                    }
                }
                scm {
                    url 'scm:git@github.com:jfxtras/jfxtras.git'
                    connection 'scm:git@github.com:jfxtras/jfxtras.git'
                    developerConnection 'scm:git@github.com:jfxtras/jfxtras.git'
                }
                developers {
                    developer { name 'Tom Eugelink' }
                }
            }
        }
    }
}

subprojects {
    // Needed until Gradle supports class-scanning for Java 9
    tasks.withType(Test) {
        scanForTestClasses = false
        include '**/*Test.class'
        include '**/*Test1.class'
        exclude 'jfxtras/labs/test/JFXtrasGuiTest.class'
    }

    apply from: rootProject.file('gradle/javadoc.gradle')

	// Force Java 9 in Eclipse config
	// https://docs.gradle.org/current/dsl/org.gradle.plugins.ide.eclipse.model.EclipseClasspath.html
	eclipse {
		classpath {
	    	containers 'org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-9/' // Add correct container
			file {
	    		whenMerged { classpath ->
	    			classpath.entries.removeAll { entry -> entry.kind == 'con' && !entry.path.contains('JavaSE-9')} // Remove all other containers
					classpath.entries.findAll{ it.kind == 'src' && it.entryAttributes['gradle_used_by_scope'].equals('test') }.each { // Mark test folders as containing test sourcers
						it.entryAttributes['test'] = 'true'
					}
				}
	   		}
	   }
	   jdt {
			sourceCompatibility = org.gradle.api.JavaVersion.VERSION_1_9 
			targetCompatibility = org.gradle.api.JavaVersion.VERSION_1_9
	   }
	}
	tasks.eclipse.dependsOn(cleanEclipse)

    // follow advise from https://guides.gradle.org/building-java-9-modules/
    afterEvaluate {
        if (project.moduleName == 'jfxtras.test.support') {
            // skip module configuration for now
            return
        }

        compileJava {
            inputs.property('moduleName', moduleName)
            doFirst {
                options.compilerArgs = [
                    '--module-path', classpath.asPath,
                ]
                classpath = files()
            }
        }
/* TODO: FIX how testing should be configured
        compileTestJava {
            inputs.property('moduleName', moduleName)
            doFirst {
                options.compilerArgs = [
                    '--module-path', classpath.asPath,
                    '--add-modules', 'junit',
                    '--add-reads', "$moduleName=junit",
                    '--patch-module', "$moduleName=" + files(sourceSets.test.java.srcDirs).asPath,
                ]
                classpath = files()
            }
        }

        test {
            inputs.property('moduleName', moduleName)
            doFirst {
                jvmArgs = [
                    '--module-path', classpath.asPath,
                    '--add-modules', 'ALL-MODULE-PATH',
                    '--add-reads', "$moduleName=junit",
                    '--patch-module', "$moduleName=" + files(sourceSets.test.java.outputDir).asPath,
                ]
                classpath = files()
            }
        }
*/
    }
}

project(':jfxtras-agenda') {
    project.ext.apiProject = true
    project.moduleName = 'jfxtras.agenda'
    dependencies {
        compile project(':jfxtras-controls')
        testCompile project(':jfxtras-test-support')
    }
}

project(':jfxtras-common') {
    project.ext.apiProject = true
    project.moduleName = 'jfxtras.common'
    dependencies {
        testCompile project(':jfxtras-test-support')
    }
}

project(':jfxtras-controls') {
    project.ext.apiProject = true
    project.moduleName = 'jfxtras.controls'
    dependencies {
        compile project(':jfxtras-common')
        compile project(':jfxtras-fxml')
        testCompile project(':jfxtras-test-support')
    }
}

project(':jfxtras-icalendarfx') {
    project.ext.apiProject = true
    project.moduleName = 'jfxtras.icalendarfx'
    dependencies {
        testCompile project(':jfxtras-test-support')
    }
}

project(':jfxtras-icalendaragenda') {
    project.ext.apiProject = true
    project.moduleName = 'jfxtras.icalendaragenda'
    dependencies {
        compile project(':jfxtras-agenda')
        compile project(':jfxtras-controls')
        compile project(':jfxtras-icalendarfx')
        testCompile project(':jfxtras-test-support')
    }
}

project(':jfxtras-menu') {
    project.ext.apiProject = true
    project.moduleName = 'jfxtras.menu'
    dependencies {
        compile project(':jfxtras-common')
        testCompile project(':jfxtras-test-support')
    }
}

project(':jfxtras-gauge-linear') {
    project.ext.apiProject = true
    project.moduleName = 'jfxtras.gauge.linear'
    dependencies {
        compile project(':jfxtras-common')
        testCompile project(':jfxtras-test-support')
    }
}

project(':jfxtras-font-roboto') {
    project.ext.apiProject = true
    project.moduleName = 'jfxtras.font.roboto'
    dependencies {
        testCompile project(':jfxtras-test-support')
    }
}

project(':jfxtras-test-support') {
    project.moduleName = 'jfxtras.test.support' // use a name even if no actual module exists
    // must configure the following dependencies with modules instead
    dependencies {
        compile "junit:junit:$junitVersion"
        compile "org.mockito:mockito-all:$mockitoVersion"
        compile "org.testfx:testfx-core:testfxVersion"
        compile "org.testfx:testfx-junit:$testfxVersion", {
            exclude group: 'junit', module: 'junit'
        }
    }
}

// wait for every subproject to be configured before reconfiguring root project
evaluationDependsOnChildren()

// find all api projects
ext.apiProjects = subprojects.findAll { prj -> prj.apiProject }.name

// mark all apiProjects as dependencies
project(':') {
    dependencies {
        apiProjects.each { projectName -> compile project(projectName) }
    }
}

// apply common settings affecting javadoc/sources
apply from: rootProject.file('gradle/javadoc.gradle')

// copy all sources to a single directory
task copyDocs(type: Copy) {
    destinationDir = "${buildDir}/sources" as File
    project.apiProjects.each { projectName ->
        from(project(projectName).sourceSets.main.allSource)
    }
}

// update dependencies on javadoc task
javadoc {
    dependsOn copyDocs
    include '**/*.java'
    source = copyDocs.destinationDir
}

// update sourcesJar
sourcesJar {
    dependsOn copyDocs
    from copyDocs.destinationDir
}

// configure shadowJar
shadowJar {
   classifier = '' // do not append "-all", so the generated shadow jar replaces the existing jfxtras-all.jar (instead of generating jfxtras-all-all.jar)
}

jar.finalizedBy shadowJar