build.gradle

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

buildscript {
	repositories {
		jcenter()
		mavenCentral()
		maven {
		  url 'https://plugins.gradle.org/m2/'
		}
	}
	dependencies {
		classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.8.4'
		classpath 'com.gradle.publish:plugin-publish-plugin:0.12.0'
	}
}

apply plugin: 'com.gradle.plugin-publish'
apply plugin: 'java-gradle-plugin'
apply plugin: 'groovy'
apply plugin: 'maven-publish'
apply plugin: 'signing'
apply plugin: 'idea'
apply plugin: 'com.jfrog.bintray'

sourceCompatibility = '1.8'
targetCompatibility = '1.8'

// Release version that won't conflict with the bintray plugin
def releaseVersion = "4.0.0"
// variables that configure the Maven upload
group = "net.saliman"
archivesBaseName = "gradle-cobertura-plugin"
version = releaseVersion
ext.isReleaseVersion = !version.endsWith("SNAPSHOT")

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

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

dependencies {
	implementation localGroovy()
	implementation gradleApi()
	implementation 'commons-io:commons-io:2.6'
	testImplementation 'junit:junit:4.12'
	testRuntimeOnly 'net.sourceforge.cobertura:cobertura:2.1.1'
}

project.tasks.publish.dependsOn 'test'

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

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

// Configure the java-gradle-plugin.  Note that the ID must match it's Gradle
// Plugin Portal id.  This will screw up Maven publishing, but we'll fix that
// later.
gradlePlugin {
	plugins {
		coberturaPlugin {
			id = 'net.saliman.cobertura'
			displayName = 'Gradle Cobertura plugin'
			description = 'A Gradle plugin for working with the Cobertura coverage tool.'
			implementationClass = 'net.saliman.gradle.plugin.cobertura.CoberturaPlugin'
		}
	}
}

// configuration for publishing to the Gradle plugins portal
pluginBundle {
	website = 'https://github.com/stevesaliman/gradle-cobertura-plugin'
	vcsUrl = 'https://github.com/stevesaliman/gradle-cobertura-plugin.git'
	description = 'A Gradle plugin for working with the Cobertura coverage tool.'
	tags = ['gradle', 'cobertura', 'coverage']
//	plugins {
//		coberturaPlugin {
//			displayName = 'Gradle Cobertura plugin'
//			description = 'A Gradle plugin for working with the Cobertura coverage tool.'
//		}
//	}
}

// Configure the maven-publish plugin
publishing {
	publications {
		coberturaPlugin(MavenPublication) {
			from components.java
			artifact groovydocJar
			artifact sourceJar
			pom {
				name = 'Gradle Cobertura Plugin'
				description = 'A Gradle plugin for runing Cobertura coverage reports.'
				url = 'https://github.com/stevesaliman/gradle-cobertura-plugin'
				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://stevesaliman@github.com/stevesaliman/gradle-cobertura-plugin'
					developerConnection = 'scm:git@github.com:stevesaliman/gradle-cobertura-plugin.git'
					url = 'https://github.com/stevesaliman/gradle-cobertura-plugin'
				}
			}

		}
	}

	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
				}
			}
		}
	}
}

// Configure BinTray publishing
bintray {
	user = project.hasProperty('bintrayUsername') ? project.getProperty('bintrayUsername') : ''
	key = project.hasProperty('bintrayApiKey') ? project.getProperty('bintrayApiKey') : ''

	publications = [ 'coberturaPlugin' ]
	publish = true

	pkg {
		// repo = 'gradle-plugins'
		repo = 'maven'
		name = 'gradle-cobertura-plugin'
		desc = 'A Gradle plugin for working with the Cobertura code coverage tool.'
		licenses = [ 'Apache-2.0' ]
		websiteUrl = 'https://github.com/stevesaliman/gradle-cobertura-plugin'
		issueTrackerUrl = 'https://github.com/stevesaliman/gradle-cobertura-plugin/issues'
		vcsUrl = 'https://github.com/stevesaliman/gradle-cobertura-plugin.git'
		labels = [ 'gradle', 'cobertura', 'coverage' ]
		publicDownloadNumbers = true
		version {
			// name = version
			// vcsTag = version
			vcsTag = "Release_${releaseVersion}"
			attributes = [
					'gradle-plugin': 'net.saliman.cobertura:net.saliman:gradle-cobertura-plugin'
			]
		}
	}
}

signing {
	sign publishing.publications.coberturaPlugin
}

// 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 a net.saliman.cobertura artifact,
	// which is wrong.  The quick and very dirty solution is to disable those
	// tasks.
	// Comment this to publish to Gradle and Bintray, 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
		}
	}
}

// The testclient links to this file in its buildSrc directory.  Gradle always
// runs tests when it builds the buildSrc contents.  This creates a circular
// reference which causes tests to hang.  Disable tests if we're building the
// plugin from the testclient's buildSrc directory.
if ( projectDir.name.endsWith('buildSrc') ) {
  println "Disabling plugin tests when building from the 'buildSrc' directory"
	test.enabled = false
}

//task release() {
//	dependsOn 'assemble', 'publish', 'bintrayUpload', 'publishPlugins'
//}