/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ boolean isUsingArtifactory = rootProject.hasProperty('artifactoryUser') && rootProject.artifactoryUser && rootProject.hasProperty('artifactoryPassword') && rootProject.artifactoryPassword if (isUsingArtifactory) { logger.lifecycle 'Deployment environment set to Artifactory' } def embedded = ['asm', 'asm-util', 'asm-analysis', 'asm-tree', 'asm-commons', 'antlr', 'commons-cli', 'openbeans'] def removeJarjaredDependencies = { p -> p.dependencies.removeAll(p.dependencies.findAll { it.groupId == 'org.codehaus.groovy' || embedded.contains(it.artifactId) }) } allprojects { if (project == rootProject || modules().contains(project)) { apply plugin: 'maven' apply from: "${rootProject.projectDir}/gradle/pomconfigurer.gradle" install.dependsOn checkCompatibility } } apply from: 'gradle/backports.gradle' ext.basename = { String s -> s.take(s.lastIndexOf('.')) } ext.deriveFile = { File archive, String suffix -> new File(archive.parent, basename(archive.name) + "-${suffix}.jar") } allprojects { if (project == rootProject || modules().contains(project)) { ext.signWithClassifier = { String c, File f -> if (rootProject.isReleaseVersion) { signing.sign(c, f) def ascFile = new File(f.parent, f.name + '.asc') if (ascFile.exists()) { project.artifacts.add('archives', ascFile) { classifier = c type = 'asc' extension = 'jar.asc' } } } } ext.signArchiveTask = { archiveTask -> if (rootProject.isReleaseVersion) { signing.sign(archiveTask.classifier, archiveTask.archivePath) def ascFile = new File(archiveTask.destinationDir, archiveTask.archiveName + '.asc') if (ascFile.exists()) { project.artifacts.add('archives', ascFile) { name = archiveTask.baseName classifier = archiveTask.classifier type = 'asc' extension = archiveTask.extension + '.asc' } } } } uploadArchives { repositories { mavenDeployer { pom pomConfigureClosure beforeDeployment { MavenDeployment deployment -> if (rootProject.isReleaseVersion) signing.signPom(deployment) } } } } install { repositories { mavenInstaller { pom pomConfigureClosure beforeDeployment { MavenDeployment deployment -> if (rootProject.isReleaseVersion) signing.signPom(deployment) } } } } artifacts { archives jar archives sourceJar archives javadocJar archives groovydocJar } [uploadArchives, install]*.with { // dependency on jarAllAll should in theory be replaced with jar, jarWithIndy but // in practice, it is faster dependsOn([jarAllAll, sourceJar, javadocJar, groovydocJar]) doFirst { if (rootProject.useIndy()) { new GradleException('You cannot use uploadArchives or install task with the flag [indy] turned' + ' on because the build handles indy artifacts by itself in that case.') } def indyJar = rootProject.ext.deriveFile(jar.archivePath, 'indy') if (indyJar.exists()) { project.artifacts.add('archives', indyJar) } def grooidJar = rootProject.ext.deriveFile(jar.archivePath, 'grooid') if (grooidJar.exists()) { project.artifacts.add('archives', grooidJar) } } } install { doFirst { // gradle doesn't expect us to mutate configurations like we do here // so signing the configuration won't work and we do it manually here signArchiveTask(jar) signArchiveTask(sourceJar) signArchiveTask(javadocJar) signArchiveTask(groovydocJar) def indyJar = rootProject.ext.deriveFile(jar.archivePath, 'indy') if (indyJar.exists()) { signWithClassifier('indy', indyJar) } def grooidJar = rootProject.ext.deriveFile(jar.archivePath, 'grooid') if (grooidJar.exists()) { signWithClassifier('grooid', grooidJar) } } } } } // the root project generates several alternate artifacts, e.g. 'groovy-all' // we don't want them in the root project so add them as artifacts with a modified name // we'll exclude the original artifacts during publication with an exclude pattern [uploadArchives, install]*.with { dependsOn([sourceAllJar, javadocAllJar, groovydocAllJar, distBin, distDoc, dist, distBin]) doFirst { project.artifacts.add('archives', jarAll) { name = 'groovy-all' } project.artifacts.add('archives', sourceAllJar) { name = 'groovy-all' } project.artifacts.add('archives', javadocAllJar) { name = 'groovy-all' } project.artifacts.add('archives', groovydocAllJar) { name = 'groovy-all' } project.artifacts.add('archives', distBin) { name = 'groovy-binary' } signArchiveTask(jarAll) signArchiveTask(sourceAllJar) signArchiveTask(javadocAllJar) signArchiveTask(groovydocAllJar) // TODO rework these? if (isReleaseVersion) { signing.sign(distBin.archivePath) def ascFile = new File(distBin.destinationDir, distBin.archiveName + '.asc') if (ascFile.exists()) { project.artifacts.add('archives', ascFile) { name = 'groovy-binary' type = 'asc' extension = 'zip.asc' } } signing.sign(distSrc.archivePath) signing.sign(distDoc.archivePath) signing.sign(dist.archivePath) } tasks.withType(Jar).matching { it.name.startsWith('backport') }.each { t -> project.artifacts.add('archives', t.archivePath) { name = t.baseName type = 'jar' classifier = t.classifier } if (isReleaseVersion) { signing.sign(t.classifier, t.archivePath) def ascFile = new File(t.destinationDir, t.archiveName + '.asc') if (ascFile.exists()) { project.artifacts.add('archives', ascFile) { name = t.baseName classifier = t.classifier type = 'asc' extension = t.extension + '.asc' } } } } def indyJar = deriveFile(jarAll.archivePath, 'indy') if (indyJar.exists()) { project.artifacts.add('archives', indyJar) signWithClassifier('indy', indyJar) } def grooidJar = deriveFile(jarAll.archivePath, 'grooid') if (grooidJar.exists()) { project.artifacts.add('archives', grooidJar) signWithClassifier('grooid', grooidJar) } } } ext.pomAll = { addFilter('groovy') { artifact, file -> !(artifact.name.contains('groovy-all')) && !(artifact.name.contains('groovy-binary')) && !(artifact.name.contains('groovy-bom')) && !(artifact.name.contains('backport')) } addFilter('all') { artifact, file -> artifact.name.contains('groovy-all') } addFilter('bom') { artifact, file -> // add an arbitrary artifact, so that the pom file is generated // we adjust the packaging attribute later artifact.name.contains('groovy-binary') } addFilter('binary') { artifact, file -> artifact.name.contains('groovy-binary') } project.backports.each { pkg, classes -> addFilter("backports-$pkg") { artifact, file -> artifact.name == "groovy-backports-$pkg" } } // regular pom def groovypom = pom('groovy', pomConfigureClosure) // pom for 'all' def allpom = pom('all', pomConfigureClosure) allpom.artifactId = 'groovy-all' // pom for binary zip def binarypom = pom('binary', pomConfigureClosureWithoutTweaks) binarypom.artifactId = 'groovy-binary' // poms for backports project.backports.each { pkg, classes -> String id = "backports-$pkg" def backportPom = pom(id, pomConfigureClosureWithoutTweaks) backportPom.artifactId = "groovy-$id" backportPom.whenConfigured { p -> p.dependencies.clear() } } modules().each { sp -> sp.install.repositories.mavenInstaller.pom.whenConfigured { subpom -> // add dependencies of other modules allpom.dependencies.addAll(subpom.dependencies) } sp.uploadArchives.repositories.mavenDeployer.pom.whenConfigured { subpom -> // add dependencies of other modules allpom.dependencies.addAll(subpom.dependencies) } } groovypom.whenConfigured(removeJarjaredDependencies) allpom.whenConfigured(removeJarjaredDependencies) binarypom.whenConfigured { p -> p.dependencies.clear() } // bom for "all" dependencies def allbom = pom('bom', pomConfigureClosureWithoutTweaks) allbom.artifactId = 'groovy-bom' allbom.whenConfigured { p -> p.dependencies.clear() // defer setting packaging until here otherwise gets overwritten p.packaging = 'pom' p.withXml { xml -> def projectNode = xml.asNode() def dependencyManagement = projectNode.appendNode('dependencyManagement').appendNode('dependencies') String groupId = project.group allprojects { proj -> if (proj.name.startsWith('groovy')) { dependencyManagement.appendNode('dependency').with { dep -> dep.appendNode('groupId', groupId) dep.appendNode('artifactId', proj.name) dep.appendNode('version', proj.version) } } } } } beforeDeployment { MavenDeployment deployment -> if (isReleaseVersion) signing.signPom(deployment) } } install { // make sure dependencies poms are built *before* the all pom dependsOn(modules()*.install) repositories { mavenInstaller pomAll } } uploadArchives { // make sure dependencies poms are built *before* the all pom dependsOn(modules()*.uploadArchives) repositories { mavenDeployer pomAll } }