build.gradle

ext.gradleVer = "7.3"
ext.groovyVersion = "3.0.17"

String gitVersion
if (hasProperty("release")) {
	gitVersion = [ "git", "describe", "--match", "[0-9]*", "--dirty"].execute().text.trim()
} else {
	gitVersion = [ "git", "describe", "--match", "[0-9]*", "--abbrev=0"].execute().text.trim() + "-SNAPSHOT"
}

task version {
	doLast {
		println "Version: ${gitVersion}"
	}
}

def ossRelease = hasProperty("oss") || hasProperty("sonatype")
def signArtifacts = ossRelease || hasProperty("sign")

allprojects {
	group = 'com.prezi.spaghetti'
	description = "Spaghetti"
	version = gitVersion
	apply plugin: 'idea'
	apply plugin: 'eclipse'

	tasks.withType(Upload).all { dependsOn "check" }
	tasks.withType(org.gradle.api.tasks.compile.JavaCompile) {
		options.compilerArgs << "-Xlint:unchecked"
	}
}

subprojects { subproject ->
	apply plugin: 'maven-publish'
	apply plugin: "java-library"

	repositories {
		mavenLocal()
		mavenCentral()
		maven {
			url "https://oss.sonatype.org/content/groups/public"
		}
		maven {
			url "https://plugins.gradle.org/m2/"
		}
		maven {
			credentials {
				username nexusUser
				password nexusPassword
			}
			url "https://artifactory.prezi.com/artifactory/plugins-release-local/"
		}
	}

	publishing {
		publications {
			mavenJava(MavenPublication) {
				from components.java
				pom {
					url = "http://github.com/prezi/spaghetti/"
					name = subproject.name
					description = subproject.description

					scm {
						url = "http://github.com:prezi/spaghetti"
						connection = "scm:git@github.com:prezi/spaghetti.git"
						developerConnection = "scm:git@github.com:prezi/spaghetti.git"
					}

					licenses {
						license {
							name = "The Apache Software License, Version 2.0"
							url = "http://www.apache.org/licenses/LICENSE-2.0.txt"
							distribution = "repo"
						}
					}

					developers {
						developer {
							id = "lptr"
							name = "Lorant Pinter"
						}
						developer {
							id = "exFalso"
							name = "Andras Slemmer"
						}
						developer {
							id = "gidapataki"
							name = "Gida Pataki"
						}
					}
				}
			}
		}
		repositories {
			maven {
				def isSnapshot = version.endsWith('SNAPSHOT')
				if (ossRelease) {
					credentials {
						username = project.getProperty("sonatypeUsername")
						password = project.getProperty("sonatypePassword")
					}
					url = isSnapshot ? "https://oss.sonatype.org/content/repositories/snapshots/" : "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
				} else if (project.hasProperty("nexusUser") && project.hasProperty("nexusPassword")) {
					credentials {
						username = project.getProperty("nexusUser")
						password = project.getProperty("nexusPassword")
					}
					def baseRepoUrl = "https://artifactory.prezi.com/artifactory"
					url = isSnapshot ? "${baseRepoUrl}/plugins-snapshot-local/" : "${baseRepoUrl}/plugins-release-local/"
				}
			}
		}
	}

	if (signArtifacts) {
		apply plugin: "signing"

		signing {
			sign publishing.publications.mavenJava
		}
	}
}

ext.codeProjects = subprojects - project(":spaghetti-docs")
ext.groovyProjects = [
		project(":spaghetti-support-test-harness"),
		project(":spaghetti-haxe-support"),
		project(":spaghetti-typescript-support")
]
ext.javaProjects = codeProjects - groovyProjects


configure(codeProjects) {
	apply plugin: 'groovy'

	sourceCompatibility = "1.8"
	targetCompatibility = "1.8"

	sourceSets {
		integTest {
			java.srcDir file('src/integTest/java')
			groovy.srcDir file('src/integTest/groovy')
			resources.srcDir file('src/integTest/resources')
		}
	}

	dependencies {
		integTestImplementation sourceSets.main.output
		integTestImplementation configurations.testImplementation
		integTestImplementation sourceSets.test.output
		integTestRuntimeOnly configurations.testRuntimeOnly
	}

	task integTest(type: Test) {
		shouldRunAfter test
		testClassesDirs = project.files(sourceSets.integTest.java.outputDir, sourceSets.integTest.groovy.outputDir)
		classpath = sourceSets.integTest.runtimeClasspath
	}

	check.dependsOn integTest

	tasks.withType(AbstractCompile) {
		options.encoding = "UTF-8"
	}

	project.dependencies {
		testImplementation "junit:junit:4.11"
		testImplementation "org.mockito:mockito-all:1.9.5"
		testImplementation("org.spockframework:spock-core:2.0-groovy-3.0") {
			exclude group: "org.codehaus.groovy"
		}
		testImplementation "org.codehaus.groovy:groovy-all:${groovyVersion}"
	}

	test {
		testLogging.showStandardStreams = true
	}

	task sourcesJar(type: Jar) {
		from sourceSets.main.allSource
		classifier = "sources"
	}

	jar {
		from rootProject.file("LICENSE.txt")
	}

	def doc
	if (project.name == "spaghetti-support-test-harness"
			|| project.name ==~ /spaghetti-(haxe|typescript)-support/) {
		doc = groovydoc
	} else {
		doc = javadoc
	}

	task docJar(type: Jar) {
		dependsOn doc
		classifier = "javadoc"
		from doc.destinationDir
	}

	artifacts {
		archives jar
		archives docJar
		archives sourcesJar
	}

	configurations {
		groovydoc { extendsFrom implementation }
	}

	dependencies {
		groovydoc "org.codehaus.groovy:groovy-all:${groovyVersion}"
	}

	String[] apis = [
		"https://docs.oracle.com/javase/8/docs/api/",
		"http://www.groovy-lang.org/gapi/",
		"https://gradle.org/docs/${gradleVer}/javadoc",
		// "http://prezi.github.io/gradle-haxe-plugin/javadoc/",
		// "http://prezi.github.io/gradle-typescript-plugin/javadoc/",
	]

	def excludes = [
		"**/internal/*",
	]

	tasks.withType(Javadoc) {
		options.encoding = "UTF-8"
		options.links apis
		options.noTimestamp = true
		exclude excludes
	}

	tasks.withType(Groovydoc) {
		groovydoc.groovyClasspath = configurations.groovydoc
		// Done in doFirst() so that we don't download stuff in configuration phase
		doFirst {
			apis.each {
				//link(it, *(new URL("$it/package-list").text.tokenize("\n")))
			}
		}
		exclude "**/internal/**"
		exclude excludes
	}
}

def inheritJavadoc(Project target, Project dependency) {
	def coreJavadoc = dependency.tasks.javadoc
	def javadocUrl = "http://prezi.github.io/spaghetti/javadoc/"

	target.javadoc {
		dependsOn coreJavadoc
		options.linksOffline javadocUrl, coreJavadoc.destinationDir.path
	}

	target.groovydoc {
		dependsOn coreJavadoc
		doFirst {
			link(javadocUrl, *(new File(coreJavadoc.destinationDir, "package-list").text.tokenize("\n")))
		}
	}
}

// Make Javadocs depend on core
configure(codeProjects - project(":spaghetti-core") - project(":spaghetti-api")) { p ->
	inheritJavadoc p, project(":spaghetti-core")
}

configure(project(":spaghetti-core")) { p ->
	inheritJavadoc p, project(":spaghetti-api")
}

configure(subprojects.findAll { it.name ==~ /gradle-spaghetti-.*-plugin/}) { p ->
	inheritJavadoc p, project(":gradle-spaghetti-plugin")
}

configure(groovyProjects) {
	dependencies {
		implementation "org.codehaus.groovy:groovy:${groovyVersion}"
	}
}

configure(subprojects.findAll { it.name ==~ /spaghetti-.*-support/ }) {
	dependencies {
		api project(path: ":spaghetti-api")
		testImplementation project(path: ":spaghetti-support-test-harness")
	}

	task zipIntegrationTestSources(type: Zip) {
		from "src/integTest/module/src"
		archiveName "integration-test-sources.zip"
	}

	processTestResources {
		from zipIntegrationTestSources
	}
}

configure(subprojects.findAll { it.name ==~ /gradle-spaghetti-.*-plugin/}) {
	dependencies {
		api project(path: ":gradle-spaghetti-plugin")
		implementation gradleApi()
	}
}