config.gradle

import org.gradle.plugins.signing.Sign

project.ext.artifactMapping = [
'git-state-plugin':                  'de.huxhorn.gradle.git-state-plugin'
]

buildscript {
	apply from: 'dependencyDefinitions.gradle'

	project.ext.localReleaseRepoFile = new File("${System.properties.'user.home'}/local-gradle-repository/release")
	project.ext.localSnapshotRepoFile = new File("${System.properties.'user.home'}/local-gradle-repository/snapshot")
	project.ext.localReleaseRepo = localReleaseRepoFile.toURL().toString()
	project.ext.localSnapshotRepo = localSnapshotRepoFile.toURL().toString()
	repositories {
		mavenLocal()
		mavenCentral()
		maven {
			url localReleaseRepo
		}
		maven {
			url localSnapshotRepo
		}
	}
	dependencies {
		// needed for syncSnapshot and syncStaging
		classpath "org.apache.maven.wagon:wagon-webdav-jackrabbit:2.2"
	}
}

gradle.taskGraph.whenReady { taskGraph ->
	if (taskGraph.allTasks.any { it instanceof Sign }) {
		String pgpPassword = System.properties.'pgpPassword'
		if(!pgpPassword) {
			java.io.Console console = System.console()
			pgpPassword = new String(console.readPassword("\nPGP Private Key Password: "))
		}
		allprojects { ext.'signing.keyId' = '740A1840' }
		allprojects { ext.'signing.secretKeyRingFile' = new File("${System.properties['user.home']}/.gnupg/secring.gpg").absolutePath }
		allprojects { ext."signing.password" = pgpPassword }
	}
}

if(!System.properties.'release') {
	defaultTasks 'build', 'uploadPublished'	
} else {
	defaultTasks 'build', 'uploadPublished', 'signJavadocZip', 'signSourceZip'	
}

allprojects {
	defaultTasks 'clean', 'build', 'uploadArchives'
	group = 'de.huxhorn.gradle'
}

project(':git-state-plugin') {
	version = '0.0.3'
	if(!System.properties.'release')
	{
		version = version + '-SNAPSHOT'
	}
}

subprojects {

	apply plugin: 'groovy'
	apply plugin: 'maven'
	apply plugin: 'signing'
    
	signing {
		if (System.properties.'release') {
			sign configurations.archives
		}
	}

	task sourceJar(type: Jar) { from sourceSets.main.allSource; classifier = 'sources' }
	task javadocJar(type: Jar) { from javadoc.outputs.files; classifier = 'javadoc' }
	
	artifacts { archives sourceJar, javadocJar }

    project.ext.defaultProject = {
    	url 'http://gradle.huxhorn.de'
    	
    	name 'gradle-pgp-plugin'
    	description 'Plugin providing the ability to sign artifacts and pom before uploading to a repository.'
    	inceptionYear '2010'
    	packaging 'jar' // does not work, fixed below
    	// See http://jira.codehaus.org/browse/GRADLE-1200

    	scm {
    		connection 'scm:git:git://github.com/huxi/huxi-gradle-plugins.git'
    		developerConnection 'scm:git:ssh://git@github.com:huxi/huxi-gradle-plugins.git'
    		url 'http://github.com/huxi/huxi-gradle-plugins/'
    	}
    	
		licenses {
			license {
				name 'GNU Lesser General Public License v3 (LGPL)'
				url 'http://www.gnu.org/copyleft/lesser.html'
				distribution 'repo'
			}
			
			license {
				name 'The Apache Software License, Version 2.0'
				url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
				distribution 'repo'
			}
		}
		
		developers {
			developer {
				id 'huxhorn'
				email 'huxhorn@users.sourceforge.net'
				name 'Joern Huxhorn'
				organization = 'Joern Huxhorn' // = is workaround for http://jira.codehaus.org/browse/GRADLE-1200
				organizationUrl 'http://lilith.huxhorn.de'
				roles {
					role 'Developer'
				}
			}
		}
		
		properties {
			'project.build.sourceEncoding' 'UTF-8'
			'project.reporting.outputEncoding' 'UTF-8'
		}
	}

    repositories {
		mavenLocal()
		mavenCentral()
		maven {
			url localReleaseRepo
		}
		maven {
			url localSnapshotRepo
		}
    }
    
    def mapped=artifactMapping[project.name];
    if(!mapped)
    {
    	throw new IllegalStateException("${project.name} does not have an entry in artifactMapping!");
    }
    archivesBaseName=mapped

	configurations {
		all*.exclude group: 'commons-logging', module: 'commons-logging'
		published.extendsFrom archives, signatures
	}
	
    dependencies {
		compile gradleApi()
		compile localGroovy()
		testCompile libraries.junit
		testCompile libraries.'slf4j-api'
		testRuntime libraries.'logback-classic'
    }

	jar {
		manifest.attributes provider: 'gradle'
	}

	def deployer = null	

	// the following is a workaround for http://jira.codehaus.org/browse/GRADLE-443
	uploadArchives {
		deployer = repositories.mavenDeployer {
			repository(url: localReleaseRepo)
			snapshotRepository(url: localSnapshotRepo)
			pom.whenConfigured { pom ->
				// dep is a native Maven dependency object (With properties artifactId, groupId, ...)
				for(dep in pom.dependencies) {
					//println(dep.artifactId)
					def mapping=artifactMapping[dep.artifactId];
					if(mapping) {
						//println("Mapping ${dep.artifactId} to ${mapping}...")
						dep.artifactId=mapping
					}
				}
			}
			beforeDeployment { MavenDeployment deployment ->
				if(System.properties.'release') {
					signing.signPom(deployment)
				}
			}
		}
	}

	def installer = install.repositories.mavenInstaller

	installer.pom.project defaultProject

	deployer.pom.project defaultProject

	// The following fixes the broken packaging
	// See http://jira.codehaus.org/browse/GRADLE-1200
	// Thanks xlson
	installer.pom.withXml { XmlProvider xmlProvider ->
		def xml = xmlProvider.asString()
		def pomXml = new XmlParser().parseText(xml.toString())

		pomXml.version[0] + { packaging('jar') }

		def newXml = new StringWriter()
		def printer = new XmlNodePrinter(new PrintWriter(newXml))
		printer.preserveWhitespace = true
		printer.print(pomXml)
		xml.setLength(0)
		xml.append(newXml.toString())
	}
	deployer.pom.withXml { XmlProvider xmlProvider ->
		def xml = xmlProvider.asString()
		def pomXml = new XmlParser().parseText(xml.toString())

		pomXml.version[0] + { packaging('jar') }

		def newXml = new StringWriter()
		def printer = new XmlNodePrinter(new PrintWriter(newXml))
		printer.preserveWhitespace = true
		printer.print(pomXml)
		xml.setLength(0)
		xml.append(newXml.toString())
	}
}


def deleteClosure
deleteClosure = {
	// delete content of it recursively
	it.eachDir( deleteClosure );
	it.eachFile {
		it.delete()
	}
}

task cleanStaging doLast({	
	deleteClosure(localReleaseRepoFile)
})

task cleanSnapshot doLast({	
	deleteClosure(localSnapshotRepoFile)
})

task syncStaging doLast({
	if (project.hasProperty('remoteUsername') && project.hasProperty('remotePassword')) {
		def stagingRepos = new org.apache.maven.wagon.repository.Repository('staging', 'https://oss.sonatype.org/service/local/staging/deploy/maven2')
		def auth = new org.apache.maven.wagon.authentication.AuthenticationInfo()
		auth.userName = remoteUsername
		auth.password = remotePassword
		def wagon = new org.apache.maven.wagon.providers.webdav.WebDavWagon()

		wagon.connect(stagingRepos, auth)
		localReleaseRepoFile.eachFile {
			if (it.directory) {
				wagon.putDirectory(it, it.name)
			} else {
				wagon.put(it, it.name)
			}
		}
	} else {
		println "Can't sync staging as credentials aren't set. Set with -PremoteUsername=user -PremotePassword=password."
	}
})

task syncSnapshot doLast({
	if (project.hasProperty('remoteUsername') && project.hasProperty('remotePassword')) {
		def snapshotRepos = new org.apache.maven.wagon.repository.Repository('snapshot', 'https://oss.sonatype.org/content/repositories/snapshots')
		def auth = new org.apache.maven.wagon.authentication.AuthenticationInfo()
		auth.userName = remoteUsername
		auth.password = remotePassword
		def wagon = new org.apache.maven.wagon.providers.webdav.WebDavWagon()

		wagon.connect(snapshotRepos, auth)
		localSnapshotRepoFile.eachFile {
			if (it.directory) {
				wagon.putDirectory(it, it.name)
			} else {
				wagon.put(it, it.name)
			}
		}
	} else {
		println "Can't sync snapshots as credentials aren't set. Set with -PremoteUsername=user -PremotePassword=password."
	}
})