build.gradle

#!groovy
// The above triggers groovy syntax highlighting in vim

buildscript {
	repositories {
		mavenCentral()
		maven {
			url "https://plugins.gradle.org/m2/"
		}
	}
}

apply plugin: "groovy"
apply plugin: "maven-publish"
apply plugin: "signing"

sourceCompatibility = 1.8
targetCompatibility = 1.8

group = "org.liquibase"
archivesBaseName = "liquibase-groovy-dsl"
version = liquibaseGroovyDslVersion
ext.isReleaseVersion = !version.endsWith("SNAPSHOT")

if ( isReleaseVersion ) {
	println "using staging"
	ext.mavenCentralUploadUrl = "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
} else {
	println "using snapshot"
	ext.mavenCentralUploadUrl = "https://oss.sonatype.org/content/repositories/snapshots/"
}

repositories {
	mavenCentral()
	mavenLocal()
}


dependencies {
	implementation "org.codehaus.groovy:groovy:${groovyVersion}"
    implementation "org.codehaus.groovy:groovy-sql:${groovyVersion}"
	// This seems redundant, but it isn't.  We need compileOnly so that the main classes will
    // compile, but that dependency doesn't transfer to the unit tests, so we also need
    // testCompile.
	compileOnly "org.liquibase:liquibase-core:${liquibaseVersion}"
	testImplementation "org.liquibase:liquibase-core:${liquibaseVersion}"
    testImplementation "junit:junit:${junitVersion}"
	testRuntimeOnly "com.h2database:h2:${h2Version}"
    testRuntimeOnly "ch.qos.logback:logback-classic:${logbackVersion}"
	archives "org.apache.maven.wagon:wagon-ssh:${wagonVersion}"
	archives "org.apache.maven.wagon:wagon-ssh-external:${wagonVersion}"
}


task sourceJar(type: Jar) {
	description = "An archive of the source code for Maven Central"
	classifier = "sources"
	from sourceSets.main.allSource
}


task groovydocJar(type: Jar, dependsOn: groovydoc) {
	description = "An archive of the GroovyDocs for Maven Central"
	classifier = "javadoc"
	from groovydoc
}

// Configure the maven-publish plugin
publishing {
	publications {
		liquibaseGroovyDsl(MavenPublication) {
			from components.java
			artifact groovydocJar
			artifact sourceJar
			pom {
				name = "Liquibase Groovy DSL"
				description = "A Groovy-based DSL for the Liquibase database refactoring tool."
				url = "https://github.com/liquibase/liquibase-groovy-dsl"
				packaging = "jar"
				licenses {
					license {
						name = "The Apache Software License, Version 2.0"
						url = "http://www.apache.org/licenses/LICENSE-2.0.txt"
					}
				}
				developers {
					developer {
						id = "stevesaliman"
						name = "Steven C. Saliman"
						email = "support@saliman.net"
					}
				}
				scm {
					connection = "scm:https://liquibase@github.com/liquibase/liquibase-groovy-dsl"
					developerConnection = "scm:git@github.com:liquibase/liquibase-groovy-dsl.git"
					url = "https://github.com/liquibase/liquibase-groovy-dsl"
				}
			}
		}
	}

	repositories {
		maven {
			url = mavenCentralUploadUrl
			// We only need to mess with credentials if we're publishing...
			if ( gradle.startParameter.taskNames.contains("publish") ) {
				// Use Java's console to read from the console (no good for a CI environment)
				def console = System.console()
				console.printf "\n\nWe have to upload some things in this build...\n\n"

				if ( !project.hasProperty("mavenCentralUsername") ) {
					def mavenCentralUsername = console.readLine("Maven Central Username: ")
					allprojects { ext."mavenCentralUsername" = mavenCentralUsername }
				}

				if ( !project.hasProperty("mavenCentralPassword") ) {
					def mavenCentralPassword = console.readLine("Maven Central Password: ")
					allprojects { ext."mavenCentralPassword" = mavenCentralPassword }
				}
				credentials {
					username mavenCentralUsername
					password mavenCentralPassword
				}
			}
		}
	}
}

signing {
	sign publishing.publications.liquibaseGroovyDsl
}

// When we're ready to go, there are a couple of things we'll need to do before we execute anything.
gradle.taskGraph.whenReady { taskGraph ->
	// This is a rather nasty little hack.  When we apply java-gradle-plugin, it creates some
    // maven-publish tasks that conflict with the manual configuration - it tries to publish an
    // org.liquibase.gradle artifact, which is wrong.  The quick and very dirty solution is to
    // disable those tasks.
	// Comment this to publish to Gradle, Uncomment for Maven Central
	taskGraph.allTasks.findAll { it.name ==~ /.*MavenPublication.*/ }*.enabled = false

	// Only *require* signing if we are uploading a release version.  If we do need to sign, make
    // sure we've got the properties we need to do the signing.
	if ( isReleaseVersion && taskGraph.hasTask(":publish") ) {
		// Use Java's console to read from the console (no good for a CI environment)
		def console = System.console()
		console.printf "\n\nWe have to sign some things in this build...\n\n"

		if ( !project.hasProperty("signing.keyId") ) {
			def id = console.readLine("PGP Public Key Id: ")
			allprojects { ext."signing.keyId" = id }
		}

		if ( !project.hasProperty("signing.secretKeyRingFile") ) {
			def file = console.readLine("PGP Secret Key Ring File (absolute path): ")
			allprojects { ext."signing.secretKeyRingFile" = file }
		}

		if ( !project.hasProperty("signing.password") ) {
			def password = console.readPassword("PGP Private Key Password: ")
			allprojects { ext."signing.password" = password }
		}

		console.printf "\nThanks.\n\n"
	} else {
		tasks.withType(org.gradle.plugins.signing.Sign).all {
			it.enabled = false
		}
	}
}