812 lines
26 KiB
Groovy
812 lines
26 KiB
Groovy
import java.nio.charset.StandardCharsets
|
|
import java.util.function.Function
|
|
|
|
import groovy.json.JsonSlurper
|
|
|
|
/*
|
|
* Hibernate, Relational Persistence for Idiomatic Java
|
|
*
|
|
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
|
|
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
|
|
*/
|
|
apply from: rootProject.file( 'gradle/base-information.gradle' )
|
|
apply from: rootProject.file( 'gradle/libraries.gradle' )
|
|
|
|
apply plugin: 'idea'
|
|
apply plugin: 'distribution'
|
|
|
|
idea.module {
|
|
}
|
|
|
|
configurations {
|
|
core
|
|
|
|
testing
|
|
|
|
envers
|
|
spatial
|
|
|
|
agroal
|
|
c3p0
|
|
hikaricp
|
|
proxool
|
|
vibur
|
|
|
|
jcache
|
|
|
|
jpamodelgen
|
|
|
|
javadocClasspath {
|
|
description = 'Class files for the javadoc to be built'
|
|
resolutionStrategy.capabilitiesResolution.withCapability('org.junit.jupiter:junit-jupiter-params:5.7.1') { details ->
|
|
details.select( details.candidates.first() ).because( 'first' )
|
|
}
|
|
|
|
extendsFrom core
|
|
extendsFrom testing
|
|
extendsFrom envers
|
|
extendsFrom spatial
|
|
extendsFrom agroal
|
|
extendsFrom c3p0
|
|
extendsFrom hikaricp
|
|
extendsFrom proxool
|
|
extendsFrom vibur
|
|
extendsFrom jcache
|
|
extendsFrom jpamodelgen
|
|
}
|
|
|
|
javadocSources {
|
|
description = 'Source files to be built by the javadoc tool'
|
|
}
|
|
}
|
|
|
|
dependencies {
|
|
attributesSchema { schema ->
|
|
schema.attribute(Bundling.BUNDLING_ATTRIBUTE) { matchStrategy ->
|
|
final def nameComparator = Comparator.comparing(
|
|
new Function<Bundling,String>() {
|
|
@Override
|
|
String apply(Bundling o) {
|
|
return o.name
|
|
}
|
|
}
|
|
)
|
|
matchStrategy.ordered(new Comparator<Bundling>() {
|
|
@Override
|
|
int compare(Bundling o1, Bundling o2) {
|
|
if ( Objects.equals( o1, o2 ) ) {
|
|
return 0;
|
|
}
|
|
|
|
if ( o1 == null ) {
|
|
return 1;
|
|
}
|
|
|
|
if ( o2 == null ) {
|
|
return -1;
|
|
}
|
|
|
|
if ( o1.name == Bundling.EMBEDDED ) {
|
|
return -1;
|
|
}
|
|
|
|
if ( o2.name == Bundling.EMBEDDED ) {
|
|
return 1;
|
|
}
|
|
|
|
return nameComparator.compare(o1,o2)
|
|
}
|
|
} )
|
|
}
|
|
}
|
|
|
|
core project( ':hibernate-core' )
|
|
javadocSources project( path: ':hibernate-core', configuration: 'javadocSources' )
|
|
|
|
testing project( ':hibernate-testing' )
|
|
javadocSources project( path: ':hibernate-testing', configuration: 'javadocSources' )
|
|
|
|
envers project( ':hibernate-envers' )
|
|
javadocSources project( path: ':hibernate-envers', configuration: 'javadocSources' )
|
|
|
|
spatial project( ':hibernate-spatial' )
|
|
javadocSources project( path: ':hibernate-spatial', configuration: 'javadocSources' )
|
|
|
|
agroal project( ':hibernate-agroal' )
|
|
javadocSources project( path: ':hibernate-agroal', configuration: 'javadocSources' )
|
|
|
|
c3p0 project( ':hibernate-c3p0' )
|
|
javadocSources project( path: ':hibernate-c3p0', configuration: 'javadocSources' )
|
|
|
|
hikaricp project( ':hibernate-hikaricp' )
|
|
javadocSources project( path: ':hibernate-hikaricp', configuration: 'javadocSources' )
|
|
|
|
proxool project( ':hibernate-proxool' )
|
|
javadocSources project( path: ':hibernate-proxool', configuration: 'javadocSources' )
|
|
|
|
vibur project( ':hibernate-vibur' )
|
|
javadocSources project( path: ':hibernate-vibur', configuration: 'javadocSources' )
|
|
|
|
// jcache project( ':hibernate-jcache' )
|
|
// javadocSources project( path: ':hibernate-jcache', configuration: 'javadocSources' )
|
|
|
|
jpamodelgen project( ':hibernate-jpamodelgen' )
|
|
javadocSources project( path: ':hibernate-jpamodelgen', configuration: 'javadocSources' )
|
|
|
|
javadocClasspath libraries.logging_annotations
|
|
javadocClasspath libraries.jakarta_validation
|
|
javadocClasspath libraries.jakarta_cdi
|
|
javadocClasspath libraries.jakarta_jacc
|
|
javadocClasspath libraries.ant
|
|
javadocClasspath libraries.postgresql
|
|
javadocClasspath gradleApi()
|
|
}
|
|
|
|
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// aggregated JavaDoc
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
|
|
final File javadocDir = mkdir( new File( (File) project.buildDir, 'documentation/javadocs' ) );
|
|
|
|
/**
|
|
* Builds the JavaDocs aggregated (unified) across all the sub-projects
|
|
*/
|
|
task aggregateJavadocs(type: Javadoc) {
|
|
description = 'Builds an aggregated JavaDoc across all ORM sub-projects'
|
|
|
|
final int currentYear = new GregorianCalendar().get( Calendar.YEAR )
|
|
|
|
source configurations.javadocSources
|
|
classpath += configurations.javadocClasspath
|
|
|
|
// exclude any generated sources and internal packages
|
|
exclude '**/generated-src/**'
|
|
exclude '**/internal/**'
|
|
include '**/*.java'
|
|
|
|
// apply standard config
|
|
maxMemory = '512m'
|
|
destinationDir = javadocDir
|
|
configure( options ) {
|
|
overview = 'src/release/javadoc/overview.html'
|
|
windowTitle = 'Hibernate JavaDocs'
|
|
docTitle = "Hibernate JavaDoc ($project.version)"
|
|
bottom = "Copyright © 2001-$currentYear <a href=\"https://redhat.com\">Red Hat, Inc.</a> All Rights Reserved."
|
|
use = true
|
|
options.encoding = 'UTF-8'
|
|
|
|
links = [
|
|
'https://docs.oracle.com/javase/8/docs/api/',
|
|
'https://docs.jboss.org/hibernate/beanvalidation/spec/2.0/api/',
|
|
'https://docs.jboss.org/cdi/api/2.0/',
|
|
'https://javaee.github.io/javaee-spec/javadocs/'
|
|
]
|
|
|
|
if ( gradle.ext.javaVersions.main.compiler.asInt() >= 11 ) {
|
|
//The need to set `--source 1.8` applies to all JVMs after 11, and also to 11
|
|
// but after excluding the first two builds; see also specific comments on
|
|
// https://bugs.openjdk.java.net/browse/JDK-8212233?focusedCommentId=14245762
|
|
// For now, let's be compatible with JDK 11.0.3+. We can improve on it if people
|
|
// complain they cannot build with JDK 11.0.0, 11.0.1 and 11.0.2.
|
|
logger.lifecycle "Forcing Javadoc in Java 8 compatible mode"
|
|
options.source = gradle.ext.baselineJavaVersion
|
|
}
|
|
|
|
options.addStringOption( 'Xdoclint:none', '-quiet' )
|
|
|
|
if ( gradle.ext.javaToolchainEnabled ) {
|
|
options.setJFlags( getProperty( 'toolchain.javadoc.jvmargs' ).toString().
|
|
split( ' ' ).toList().findAll( { !it.isEmpty() } ) )
|
|
}
|
|
}
|
|
|
|
if ( gradle.ext.javaToolchainEnabled ) {
|
|
// Display version of Java tools
|
|
doFirst {
|
|
if ( javadocTool.present ) {
|
|
logger.lifecycle "Aggregating javadoc with '${javadocTool.get().metadata.installationPath}'"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
task stageIntegrationGuide(type: Copy) {
|
|
group 'Release'
|
|
|
|
dependsOn ':documentation:buildDocsForPublishing'
|
|
|
|
from "${project( ':documentation' ).buildDir}/asciidoc/integrationguide"
|
|
into "${buildDir}/documentation/integrationguide"
|
|
}
|
|
|
|
|
|
task stageQuickstart(type: Copy) {
|
|
group 'Release'
|
|
|
|
dependsOn ':documentation:buildDocsForPublishing'
|
|
|
|
from "${project( ':documentation' ).buildDir}/asciidoc/quickstart"
|
|
into "${buildDir}/documentation/quickstart"
|
|
}
|
|
|
|
|
|
task stageTopicalGuide(type: Copy) {
|
|
group 'Release'
|
|
|
|
dependsOn ':documentation:buildDocsForPublishing'
|
|
|
|
from "${project( ':documentation' ).buildDir}/asciidoc/topical"
|
|
into "${buildDir}/documentation/topical"
|
|
}
|
|
|
|
|
|
task stageUserGuide(type: Copy) {
|
|
group 'Release'
|
|
|
|
dependsOn ':documentation:buildDocsForPublishing'
|
|
|
|
from "${project( ':documentation' ).buildDir}/asciidoc/userguide"
|
|
into "${buildDir}/documentation/userguide"
|
|
}
|
|
|
|
/**
|
|
* Assembles all documentation into the {buildDir}/documentation directory.
|
|
*
|
|
* Depends on building the docs
|
|
*/
|
|
task assembleDocumentation {
|
|
group 'Release'
|
|
description 'Assembles all documentation into the {buildDir}/documentation directory'
|
|
|
|
dependsOn ':documentation:buildDocsForPublishing'
|
|
dependsOn tasks.aggregateJavadocs
|
|
dependsOn tasks.stageIntegrationGuide
|
|
dependsOn tasks.stageTopicalGuide
|
|
dependsOn tasks.stageQuickstart
|
|
dependsOn tasks.stageUserGuide
|
|
}
|
|
|
|
//task assembleProjectTemplates(type:Copy, dependsOn: project( ":project-template" ).tasks.assembleDist) {
|
|
// def templateProject = project( ":project-template" )
|
|
// from templateProject.layout.buildDirectory.dir( "distributions" )
|
|
// into projectTemplateStagingDir
|
|
//}
|
|
|
|
/**
|
|
* Upload the documentation to the JBoss doc server
|
|
*/
|
|
task uploadDocumentation(type:Exec) {
|
|
group 'Release'
|
|
description 'Uploads documentation to the JBoss doc server'
|
|
|
|
dependsOn assembleDocumentation
|
|
|
|
final String url = "filemgmt.jboss.org:/docs_htdocs/hibernate/orm/${rootProject.ormVersion.family}";
|
|
|
|
executable 'rsync'
|
|
args '-avz', '--links', '--protocol=28', "${buildDir}/documentation/", url
|
|
|
|
doFirst {
|
|
if ( rootProject.ormVersion.isSnapshot ) {
|
|
logger.error( "Cannot perform upload of SNAPSHOT documentation" );
|
|
throw new RuntimeException( "Cannot perform upload of SNAPSHOT documentation" );
|
|
}
|
|
else {
|
|
logger.lifecycle( "Uploading documentation [{$url}]..." )
|
|
}
|
|
}
|
|
|
|
doLast {
|
|
logger.lifecycle( 'Done uploading documentation' )
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Configuration of the distribution plugin, used to build release bundle as both ZIP and TGZ
|
|
*/
|
|
distributions {
|
|
main {
|
|
distributionBaseName = 'hibernate-release'
|
|
contents {
|
|
from rootProject.file( 'lgpl.txt' )
|
|
from rootProject.file( 'changelog.txt' )
|
|
from rootProject.file( 'hibernate_logo.gif' )
|
|
|
|
into('lib/required') {
|
|
from configurations.core
|
|
}
|
|
|
|
// todo (6.0) - add back
|
|
// into( 'project-template' ) {
|
|
// // todo : hook in some form of variable replacement - especially for version
|
|
// from project( ':project-template' ).files( 'src/main/dist' )
|
|
// }
|
|
|
|
into( 'lib/spatial' ) {
|
|
from( configurations.spatial - configurations.core )
|
|
}
|
|
|
|
into( 'lib/jpa-metamodel-generator' ) {
|
|
from( configurations.jpamodelgen - configurations.core )
|
|
}
|
|
|
|
into( 'lib/envers' ) {
|
|
from( configurations.envers - configurations.core )
|
|
}
|
|
|
|
// into( 'lib/testing' ) {
|
|
// from( configurations.testing - configurations.core )
|
|
// }
|
|
//
|
|
into( 'lib/optional' ) {
|
|
into( 'agroal' ) {
|
|
from( configurations.agroal - configurations.core )
|
|
}
|
|
into( 'c3p0' ) {
|
|
from( configurations.c3p0 - configurations.core )
|
|
}
|
|
into( 'hikaricp' ) {
|
|
from( configurations.hikaricp - configurations.core )
|
|
}
|
|
into( 'jcache' ) {
|
|
from( configurations.jcache - configurations.core )
|
|
}
|
|
into( 'proxool' ) {
|
|
from( configurations.proxool - configurations.core )
|
|
}
|
|
into( 'vibur' ) {
|
|
from( configurations.vibur - configurations.core )
|
|
}
|
|
}
|
|
|
|
into('documentation') {
|
|
from "${buildDir}/documentation"
|
|
}
|
|
|
|
into( 'project' ) {
|
|
from ( rootProject.projectDir ) {
|
|
exclude( '.git' )
|
|
exclude( '.gitignore' )
|
|
exclude( 'changelog.txt' )
|
|
exclude( 'lgpl.txt' )
|
|
exclude( 'hibernate_logo.gif' )
|
|
exclude( 'tagRelease.sh' )
|
|
exclude( 'gradlew' )
|
|
exclude( 'gradlew.bat' )
|
|
exclude( 'wrapper/*' )
|
|
exclude( '**/.gradle/**' )
|
|
exclude( '**/target/**' )
|
|
exclude( '.idea' )
|
|
exclude( '**/*.ipr' )
|
|
exclude( '**/*.iml' )
|
|
exclude( '**/*.iws' )
|
|
exclude( '**/atlassian-ide-plugin.xml' )
|
|
exclude( '**/.classpath' )
|
|
exclude( '**/.project' )
|
|
exclude( '**/.settings' )
|
|
exclude( '**/.nbattrs' )
|
|
exclude( '**/out/**' )
|
|
exclude( '**/bin/**' )
|
|
exclude( 'build/**' )
|
|
exclude( '*/build/**' )
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
distTar.compression = Compression.GZIP
|
|
|
|
distTar.dependsOn assembleDocumentation
|
|
distZip.dependsOn assembleDocumentation
|
|
|
|
/**
|
|
* "virtual" task for building both types of dist bundles
|
|
*/
|
|
task buildBundles {
|
|
group 'Release'
|
|
description 'Builds all release bundles'
|
|
|
|
dependsOn distZip
|
|
dependsOn distTar
|
|
}
|
|
|
|
task uploadBundlesSourceForge(type: Exec) {
|
|
group 'Release'
|
|
description 'Uploads release bundles to SourceForge'
|
|
|
|
dependsOn buildBundles
|
|
|
|
final String url = "frs.sourceforge.net:/home/frs/project/hibernate/hibernate-orm/${version}";
|
|
|
|
executable 'rsync'
|
|
args '-vr', '-e ssh', "${project.buildDir}/distributions/", url
|
|
|
|
doFirst {
|
|
if ( rootProject.ormVersion.isSnapshot ) {
|
|
logger.error( "Cannot perform upload of SNAPSHOT bundles to SourceForge" );
|
|
throw new RuntimeException( "Cannot perform upload of SNAPSHOT bundles to SourceForge" )
|
|
}
|
|
else {
|
|
logger.lifecycle( "Uploading release bundles to SourceForge..." )
|
|
}
|
|
}
|
|
|
|
doLast {
|
|
logger.lifecycle( 'Done uploading release bundles to SourceForge' )
|
|
}
|
|
}
|
|
|
|
configurations {
|
|
bundles {
|
|
description = 'Configuration used to group the archives output from the distribution plugin.'
|
|
}
|
|
}
|
|
|
|
artifacts {
|
|
bundles distTar
|
|
bundles distZip
|
|
}
|
|
|
|
task releaseChecks {
|
|
group 'Release'
|
|
description 'Checks and preparation for release'
|
|
}
|
|
|
|
task changeLogFile {
|
|
group 'Release'
|
|
description 'Updates the changelog.txt file based on the change-log report from Jira'
|
|
|
|
dependsOn project.tasks.releaseChecks
|
|
|
|
doFirst {
|
|
logger.lifecycle( "Appending version `${project.releaseVersion}` to changelog..." )
|
|
ChangeLogFile.update( ormVersion.fullName );
|
|
}
|
|
}
|
|
|
|
task changeToReleaseVersion {
|
|
group 'Release'
|
|
description 'Updates `gradle/version.properties` file to the specified release-version'
|
|
|
|
dependsOn project.tasks.releaseChecks
|
|
|
|
doFirst {
|
|
logger.lifecycle( "Updating version-file to release-version : `${project.releaseVersion}`" )
|
|
updateVersionFile( project.releaseVersion )
|
|
}
|
|
}
|
|
|
|
task gitPreparationForRelease {
|
|
dependsOn changeLogFile
|
|
dependsOn changeToReleaseVersion
|
|
|
|
doLast {
|
|
logger.lifecycle( "Performing pre-steps Git commit : `${project.releaseVersion}`" )
|
|
executeGitCommand( 'add', '.' )
|
|
executeGitCommand( 'commit', '-m', "Pre-steps for release : `${project.ormVersion.fullName}`" )
|
|
}
|
|
}
|
|
|
|
task changeToDevelopmentVersion {
|
|
group 'Release'
|
|
description 'Updates `gradle/version.properties` file to the specified development-version'
|
|
|
|
dependsOn project.tasks.releaseChecks
|
|
|
|
doFirst {
|
|
logger.lifecycle( "Updating version-file to development-version : `${project.developmentVersion}`" )
|
|
updateVersionFile( project.developmentVersion )
|
|
}
|
|
}
|
|
|
|
task gitTasksAfterRelease {
|
|
dependsOn changeToDevelopmentVersion
|
|
|
|
doLast {
|
|
logger.lifecycle( "Performing pre-steps Git commit : `${project.releaseVersion}`" )
|
|
executeGitCommand( 'add', '.' )
|
|
executeGitCommand( 'commit', '-m', "Post-steps for release : `${project.ormVersion.fullName}`" )
|
|
|
|
if ( project.createTag ) {
|
|
logger.lifecycle("Tagging release : `${project.releaseTag}`...")
|
|
executeGitCommand( 'tag', project.releaseTag )
|
|
}
|
|
}
|
|
}
|
|
|
|
void updateVersionFile(String version) {
|
|
logger.lifecycle( "Updating `gradle/version.properties` version to `${version}`" )
|
|
project.ormVersionFile.text = "hibernateVersion=${version}"
|
|
}
|
|
|
|
task publishReleaseArtifacts {
|
|
dependsOn releaseChecks
|
|
dependsOn uploadDocumentation
|
|
dependsOn uploadBundlesSourceForge
|
|
|
|
mustRunAfter gitPreparationForRelease
|
|
}
|
|
|
|
task release {
|
|
group 'Release'
|
|
description 'Performs a release on local check-out, including updating changelog and '
|
|
|
|
dependsOn gitPreparationForRelease
|
|
dependsOn publishReleaseArtifacts
|
|
|
|
finalizedBy gitTasksAfterRelease
|
|
}
|
|
|
|
rootProject.subprojects.each { Project subProject ->
|
|
if ( project.name != subProject.name ) {
|
|
if ( subProject.tasks.findByName( 'release' ) ) {
|
|
project.tasks.publishReleaseArtifacts.dependsOn( subProject.tasks.release )
|
|
subProject.tasks.release.dependsOn( releaseChecks )
|
|
subProject.tasks.release.mustRunAfter( releaseChecks )
|
|
}
|
|
}
|
|
}
|
|
|
|
task ciReleaseChecks {
|
|
dependsOn releaseChecks
|
|
}
|
|
|
|
task gitTasksAfterCiRelease {
|
|
dependsOn gitTasksAfterRelease
|
|
|
|
doLast {
|
|
if ( project.createTag ) {
|
|
logger.lifecycle( "Pushing branch and tag to remote `${project.gitRemote}`..." )
|
|
executeGitCommand( 'push', '--atomic', project.gitRemote , project.gitBranch, project.releaseTag )
|
|
}
|
|
else {
|
|
logger.lifecycle("Pushing branch to remote `${project.gitRemote}`..." )
|
|
executeGitCommand( 'push', project.gitRemote , project.gitBranch )
|
|
}
|
|
}
|
|
}
|
|
|
|
task ciRelease {
|
|
group 'Release'
|
|
description 'Performs a release: the hibernate version is set and the changelog.txt file updated, the changes are pushed to github, then the release is performed, tagged and the hibernate version is set to the development one.'
|
|
|
|
dependsOn ciReleaseChecks
|
|
dependsOn release
|
|
|
|
finalizedBy gitTasksAfterCiRelease
|
|
}
|
|
|
|
static String executeGitCommand(Object ... subcommand){
|
|
List<Object> command = ['git']
|
|
Collections.addAll( command, subcommand )
|
|
def proc = command.execute()
|
|
def code = proc.waitFor()
|
|
def stdout = inputStreamToString( proc.getInputStream() )
|
|
def stderr = inputStreamToString( proc.getErrorStream() )
|
|
if ( code != 0 ) {
|
|
throw new GradleException( "An error occurred while executing " + command + "\n\nstdout:\n" + stdout + "\n\nstderr:\n" + stderr )
|
|
}
|
|
return stdout
|
|
}
|
|
|
|
static String inputStreamToString(InputStream inputStream) {
|
|
inputStream.withCloseable { ins ->
|
|
new BufferedInputStream(ins).withCloseable { bis ->
|
|
new ByteArrayOutputStream().withCloseable { buf ->
|
|
int result = bis.read();
|
|
while (result != -1) {
|
|
buf.write((byte) result);
|
|
result = bis.read();
|
|
}
|
|
return buf.toString( StandardCharsets.UTF_8.name());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
class ChangeLogFile {
|
|
|
|
// Get the Release Notes from Jira and add them to the Hibernate changelog.txt file
|
|
static void update(String releaseVersion) {
|
|
def text = ""
|
|
File changelog = new File( "changelog.txt" )
|
|
def newReleaseNoteBlock = getNewReleaseNoteBlock(releaseVersion)
|
|
changelog.eachLine {
|
|
line ->
|
|
if ( line.startsWith( "Note:" ) ) {
|
|
text += line + System.lineSeparator() + System.lineSeparator() + newReleaseNoteBlock
|
|
}
|
|
else {
|
|
text += line + System.lineSeparator()
|
|
}
|
|
}
|
|
changelog.text = text
|
|
}
|
|
|
|
// Get the Release Notes from Jira
|
|
static String getNewReleaseNoteBlock(String releaseVersion) {
|
|
def restReleaseVersion;
|
|
if ( releaseVersion.endsWith( ".Final" ) ) {
|
|
restReleaseVersion = releaseVersion.replace( ".Final", "" )
|
|
}
|
|
else {
|
|
restReleaseVersion = releaseVersion
|
|
}
|
|
def apiString = "https://hibernate.atlassian.net/rest/api/2/search/?jql=project=HHH%20AND%20fixVersion=${restReleaseVersion}%20order%20by%20issuetype%20ASC"
|
|
def apiUrl = new URL( apiString )
|
|
def jsonReleaseNotes = new JsonSlurper().parse( apiUrl )
|
|
def releaseDate = new Date().format( 'MMMM dd, YYYY' )
|
|
def versionId = getVersionId( jsonReleaseNotes, restReleaseVersion )
|
|
|
|
ReleaseNote releaseNotes = new ReleaseNote( releaseVersion, releaseDate, versionId )
|
|
|
|
def issuetype
|
|
jsonReleaseNotes.issues.each {
|
|
issue ->
|
|
if ( issuetype != issue.fields.issuetype.name ) {
|
|
issuetype = issue.fields.issuetype.name
|
|
releaseNotes.addEmptyLine();
|
|
releaseNotes.addLine( "** ${issue.fields.issuetype.name}" )
|
|
}
|
|
releaseNotes.addLine( " * [" + issue.key + "] - " + issue.fields.summary )
|
|
}
|
|
releaseNotes.addEmptyLine()
|
|
return releaseNotes.notes
|
|
}
|
|
|
|
private static getVersionId(jsonReleaseNotes, String restReleaseVersion) {
|
|
def fixVersions = jsonReleaseNotes.issues.get( 0 ).fields.fixVersions
|
|
|
|
for ( def fixVersion : fixVersions ) {
|
|
if ( fixVersion.name.equals( restReleaseVersion ) ) {
|
|
return fixVersion.id
|
|
}
|
|
}
|
|
throw new GradleException( "Unable to determine the version id of the current release." )
|
|
}
|
|
}
|
|
|
|
class ReleaseNote {
|
|
String notes;
|
|
String notesHeaderSeparator = "------------------------------------------------------------------------------------------------------------------------"
|
|
|
|
ReleaseNote(String releaseVersion, String releaseDate, String versionId) {
|
|
notes = "Changes in ${releaseVersion} (${releaseDate})" + System.lineSeparator()
|
|
addHeaderSeparator()
|
|
addEmptyLine()
|
|
addLine( "https://hibernate.atlassian.net/projects/HHH/versions/${versionId}" )
|
|
}
|
|
|
|
void addLine(String text) {
|
|
notes += text + System.lineSeparator()
|
|
}
|
|
|
|
void addHeaderSeparator() {
|
|
addLine( notesHeaderSeparator )
|
|
}
|
|
|
|
void addEmptyLine() {
|
|
notes += System.lineSeparator()
|
|
}
|
|
|
|
void addEmptyLines(int numberOfLines) {
|
|
for ( i in 1..numberOfLines ) {
|
|
notes += System.lineSeparator()
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
gradle.getTaskGraph().whenReady {tg->
|
|
|
|
if ( tg.hasTask( project.tasks.releaseChecks ) ) {
|
|
String releaseVersionLocal
|
|
String developmentVersionLocal
|
|
|
|
def console = tg.hasTask( project.tasks.ciReleaseChecks )
|
|
? null
|
|
: System.console()
|
|
|
|
if (project.hasProperty('releaseVersion')) {
|
|
releaseVersionLocal = project.property('releaseVersion')
|
|
}
|
|
else {
|
|
if (console) {
|
|
// prompt for `releaseVersion`
|
|
releaseVersionLocal = console.readLine('> Enter the release version: ')
|
|
}
|
|
else {
|
|
throw new GradleException(
|
|
"`release`-related tasks require the following properties: 'releaseVersion', 'developmentVersion'"
|
|
)
|
|
}
|
|
}
|
|
|
|
if (project.hasProperty('developmentVersion')) {
|
|
developmentVersionLocal = project.property('developmentVersion')
|
|
}
|
|
else {
|
|
if (console) {
|
|
// prompt for `developmentVersion`
|
|
developmentVersionLocal = console.readLine('> Enter the next development version: ')
|
|
}
|
|
else {
|
|
throw new GradleException(
|
|
"`release`-related tasks require the following properties: 'releaseVersion', 'developmentVersion'"
|
|
)
|
|
}
|
|
}
|
|
|
|
assert releaseVersionLocal != null && developmentVersionLocal != null;
|
|
|
|
// set up information for the release-related tasks
|
|
project.ext {
|
|
releaseVersion = releaseVersionLocal;
|
|
developmentVersion = developmentVersionLocal;
|
|
createTag = !project.hasProperty('noTag')
|
|
releaseTag = project.createTag ? determineReleaseTag(releaseVersionLocal) : ''
|
|
}
|
|
|
|
logger.lifecycle("Checking that the working tree is clean...")
|
|
String uncommittedFiles = executeGitCommand('status', '--porcelain')
|
|
if (!uncommittedFiles.isEmpty()) {
|
|
throw new GradleException(
|
|
"Cannot release because there are uncommitted or untracked files in the working tree.\n" +
|
|
"Commit or stash your changes first.\n" +
|
|
"Uncommitted files:\n " +
|
|
uncommittedFiles
|
|
);
|
|
}
|
|
|
|
if (tg.hasTask(project.tasks.ciReleaseChecks)) {
|
|
String gitBranchLocal
|
|
String gitRemoteLocal
|
|
|
|
if (project.hasProperty('gitBranch')) {
|
|
gitBranchLocal = project.property('gitBranch')
|
|
}
|
|
else {
|
|
gitBranchLocal = executeGitCommand( 'branch', '--show-current' )
|
|
}
|
|
|
|
if (project.hasProperty('gitRemote')) {
|
|
gitRemoteLocal = project.property('gitRemote')
|
|
}
|
|
else {
|
|
final String remotes = executeGitCommand( 'remote', 'show' )
|
|
final List<String> tokens = remotes.tokenize()
|
|
if ( tokens.size() != 1 ) {
|
|
throw new GradleException( "Could not determine `gitRemote` property for `ciRelease` tasks." )
|
|
}
|
|
gitRemoteLocal = tokens.get( 0 )
|
|
}
|
|
|
|
project.ext {
|
|
gitBranch = gitBranchLocal
|
|
gitRemote = gitRemoteLocal
|
|
}
|
|
|
|
logger.lifecycle("Switching to branch '${project.gitBranch}'...")
|
|
executeGitCommand('checkout', project.gitBranch)
|
|
|
|
logger.lifecycle("Checking that all commits are pushed...")
|
|
String diffWithUpstream = executeGitCommand('diff', '@{u}')
|
|
if (!diffWithUpstream.isEmpty()) {
|
|
throw new GradleException(
|
|
"Cannot perform `ciRelease` tasks because there are un-pushed local commits .\n" +
|
|
"Push your commits first."
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static String determineReleaseTag(String releaseVersion) {
|
|
return releaseVersion.endsWith( '.Final' )
|
|
? releaseVersion.replace( ".Final", "" )
|
|
: releaseVersion;
|
|
} |