publish-maven.gradle

apply plugin: 'maven-publish'

//alias install -> publishToMavenLocal
task install(dependsOn: 'publishToMavenLocal') {}

// exclude hadoop install sub projects
def hadoopInstalls = ['cdh5', 'hadoop27', 'hdp22', 'phd21', 'phd30']
if (hadoopInstalls.contains(project.name)) {
	project.tasks.findByPath("artifactoryPublish")?.enabled = false
}

def nonPublishedProjects = hadoopInstalls + 'documentation-toolchain'

def customizePom = {
	description project.description
        name project.name
	url linkHomepage
	organization {
		name 'Spring by Pivotal'
		url 'https://spring.io'
	}
	licenses {
		license {
			name 'The Apache Software License, Version 2.0'
			url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
			distribution 'repo'
		}
	}

	scm {
		url linkScmUrl
		connection linkScmConnection
		developerConnection linkScmDevConnection
	}

	developers {
		xdDevelopers.each { dev ->
			developer {
				id dev.id
				name dev.name
				if (dev.email) {
					email dev.email
				}
			}
		}
	}
}

// This is needed to generate elements that are also defined methods in MavenPublication
customizePom.resolveStrategy = Closure.DELEGATE_FIRST

task sourceJar(type: Jar) {
	from sourceSets.main.allJava
}


task javadocMaven(type: Jar, dependsOn: javadoc) {
	from javadoc.destinationDir
}

def providedDep = { dep ->
	dependency {
		artifactId dep.name
		groupId dep.group
		version dep.version
		scope provided
	}
}

providedDep.resolveStrategy = Closure.DELEGATE_ONLY

class ProjectDependenciesVersionResolver {
	Map<String, ResolvedDependency>  resolvedDependencies = [:]

	ProjectDependenciesVersionResolver(project) {
		project.configurations.findAll {
			['compile', 'runtime', 'default', 'optional', 'provided'].contains(it.name)
		}.each { cfg ->
			cfg.resolvedConfiguration.firstLevelModuleDependencies.each { dep ->
				def existing = resolvedDependencies.get("${dep.moduleGroup}:${dep.moduleName}".toString(), dep)
				if (!existing) {
					existing = resolvedDependencies.put("${dep.moduleGroup}:${dep.moduleName}".toString(), dep)
					
				}

				//TODO: This may never happen, but added here just in case it does.
				else {
					assert existing.moduleVersion == dep.moduleVersion:
							"Cannot resolve dependency version for ${project.name}. Different versions ${dep} ${existing}"
				}
			}
		}
	}

	def getVersion(groupId, artifactId) {
		def dep = resolvedDependencies["${groupId}:${artifactId}".toString()]
		assert dep: "Unable to resolve dependency version for ${groupId}:${artifactId}"
		return dep.moduleVersion
	}
}

//Note setting enabled=false on publishing tasks doesn't work as expected
if (!nonPublishedProjects.contains(project.name)) {
	publishing {
		publications {
			mavenCustom(MavenPublication) {

				from components.java

				artifact sourceJar {
					classifier 'sources'
				}

				artifact javadocMaven {
					classifier 'javadoc'
				}

				pom.withXml {

					def projectDependenciesVersionResolver = new ProjectDependenciesVersionResolver(project)

					asNode().version + customizePom

					asNode().dependencies.'*'.each {

						// Add version as the 3rd element
						it.version ||
								it.children().add(2,
										new Node(null, 'version', 
										projectDependenciesVersionResolver.getVersion(it.groupId.text(), it.artifactId.text())))
					}

					project.configurations.optional.allDependencies.each { dep ->
						def mvnDep = asNode().dependencies.'*'.find {
							it.artifactId.text() == dep.name && it.groupId.text() == dep.group
						}
						new Node(mvnDep, 'optional', 'true')
					}
					project.configurations.provided.allDependencies.each { dep ->
						def mvnDep = asNode().dependencies.'*'.find {
							it.artifactId.text() == dep.name && it.groupId.text() == dep.group
						}
						if (mvnDep) {
							mvnDep.scope*.replaceNode(new Node(null, 'scope', 'provided'))
						} else {
							asNode().dependencies + providedDep(dep)
						}
					}

					project.configurations.compile.allDependencies.each { dep ->
						// Since provided is a subset of compile or runtime, 'runtime' guard is required here to preserve
						// dependencies already changed to 'provided' above
						def mvnDep = asNode().dependencies.'*'.find {
							it.artifactId.text() == dep.name && it.groupId.text() == dep.group && it.scope?.text() == 'runtime'
						}
						mvnDep?.scope*.replaceNode(new Node(null, 'scope', 'compile'))
					}

					// 
					// This plugin does not support excludes applied to configurations.
					//
					asNode().dependencies.'*'.each { mvnDep ->
						def scope = mvnDep.scope ? mvnDep.scope.text() : 'compile'
						def configuration = project.configurations."${scope}"

						configuration.excludeRules.each { ex ->
							// TODO: Extra credit for getting the builder style to work here (see 'providedDep' above)
							if (mvnDep.exclusions) {
								def exclusion = new Node(mvnDep.exclusions[0], 'exclusion', null)
								new Node(exclusion, 'groupId', ex.group)
								new Node(exclusion, 'artifactId', ex.module ?: '*')
							} else {
								def exclusions = new Node(mvnDep, 'exclusions', null)
								def exclusion = new Node(exclusions, 'exclusion', null)
								new Node(exclusion, 'groupId', ex.group)
								new Node(exclusion, 'artifactId', ex.module ?: '*')
							}
						}
					}
				}
			}
		}
	}
}