release.gradle

/*
 * SPDX-License-Identifier: Apache-2.0
 * Copyright Red Hat Inc. and Hibernate Authors
 */
import java.nio.charset.StandardCharsets

import groovy.json.JsonSlurper



plugins {
    id "local.module"
    id "org.hibernate.orm.build.doc-pub"
    id "org.hibernate.orm.build.jdks"

    id "idea"
}

idea.module {
}

// skip building this when `build` task is run from root, as many of our CI jobs do
tasks.build.dependsOn.clear()
tasks.build.enabled false


// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Stage - Release Prepare : see `releasePrepare`
//
// This coordinates:
//      1. some pre-release checks
//		2. updating the changelog
//		3. update version.properties to RELEASE_VERSION
//		4. assemble documentation (we want this to run here as a "check")
//		5. git commit (changelog and RELEASE_VERSION)
//		6. update version.properties to DEVELOPMENT_VERSION
//		7. git tag
//		8. git commit (DEVELOPMENT_VERSION)
//
// and at some point in these steps, it assembles documentation.  the order is unimportant
//
//	NOTE : ideally we'd switch (6) and (7).  it works out as-is, but confusing
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

def releaseChecksTask = tasks.register( "releaseChecks" ) {
    group 'release-prepare'
    description 'Checks and preparation for release'

    doFirst {
        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
            );
        }

        String gitBranchLocal
        String gitRemoteLocal

        if (project.hasProperty('gitBranch') && !project.property('gitBranch').isEmpty()) {
            gitBranchLocal = project.property('gitBranch')
        }
        else {
            gitBranchLocal = executeGitCommand( 'branch', '--show-current' ).trim()
        }

        if (project.hasProperty('gitRemote') && !project.property('gitRemote').isEmpty()) {
            gitRemoteLocal = project.property('gitRemote')
        }
        else {
            final String remotes = executeGitCommand( 'remote', 'show' ).trim()
            final List<String> tokens = remotes.tokenize()
            if ( tokens.size() != 1 ) {
                throw new GradleException( "Could not determine `gitRemote` property for `releaseChecks` 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."
            );
        }
    }
}

def changeLogFileTask = tasks.register( "changeLogFile" ) {
    group 'release-prepare'
    description 'Updates the changelog.txt file based on the change-log report from Jira'
    dependsOn releaseChecksTask

    doFirst {
        logger.lifecycle( "Appending version `${project.releaseVersion}` to changelog..." )
        ChangeLogFile.update( ormBuildDetails.hibernateVersion.fullName );
    }
}

def changeToReleaseVersionTask = tasks.register( "changeToReleaseVersion" ) {
    group 'release-prepare'
    description 'Updates `gradle/version.properties` file to the specified release-version'

    dependsOn releaseChecksTask

    doFirst {
        def releaseVersion = ormBuildDetails.releaseDetails.releaseVersion
        logger.lifecycle( "Updating version-file to release-version : `${releaseVersion}`" )
        updateVersionFile( releaseVersion.toString() )
    }
}

def gitPreStepsTask = tasks.register( 'gitPreSteps' ) {
    group "release-prepare"
    description "update changelog, update version file and commit"

    dependsOn releaseChecksTask
    dependsOn changeLogFileTask
    dependsOn changeToReleaseVersionTask

    doLast {
        def releaseVersion = ormBuildDetails.releaseDetails.releaseVersion
        logger.lifecycle( "Performing pre-steps Git commit : `${releaseVersion}`" )
        executeGitCommand( 'add', '.' )
        executeGitCommand( 'commit', '-m', "Pre-steps for release : `${releaseVersion.fullName}`" )
    }
}

def gitPostStepsTask = tasks.register( 'gitPostSteps' ) {
    group "release-prepare"
    description "possibly create tag. update version-file and commit "

    doFirst {
    }

    doLast {
        def releaseDetails = ormBuildDetails.releaseDetails
        def releaseVersion = releaseDetails.releaseVersion
        def developmentVersion = releaseDetails.developmentVersion

        if ( releaseDetails.shouldCreateTag() ) {
            logger.lifecycle( "Tagging release : `${releaseDetails.tagNameToUse}`..." )
            executeGitCommand( 'tag', '-a', releaseDetails.tagNameToUse, '-m', "Release $releaseVersion.fullName" )
        }

        logger.lifecycle( "Updating version-file to development-version : `${developmentVersion.fullName}`" )
        updateVersionFile( developmentVersion.toString() )

        logger.lifecycle( "Performing post-steps Git commit : `${releaseVersion}`" )
        executeGitCommand( 'add', '.' )
        executeGitCommand( 'commit', '-m', "Post-steps for release : `${releaseVersion.fullName}`" )
    }
}

void updateVersionFile(String version) {
    logger.lifecycle( "Updating `gradle/version.properties` version to `${version}`" )
    ormBuildDetails.versionFileAccess.get().text = "hibernateVersion=${version}"
}

tasks.register("releasePrepare") {
    group "release-prepare"
    description "Scripted release 'Release Prepare' stage"

    dependsOn releaseChecksTask
    dependsOn "assembleDocumentation"
    dependsOn gitPreStepsTask

    finalizedBy gitPostStepsTask
}

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Assemble documentation as part of Release Prepare
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

def stageIntegrationGuideTask = tasks.register( "stageIntegrationGuide", Copy ) {
    group "documentation"
    description "Stages the Integration Guide as part of assembling documentation in preparation for release"

    dependsOn ":documentation:renderIntegrationGuides"

    from project.provider { project( ":documentation" ).layout.buildDirectory.dir( "asciidoc/integrationguide" ) }
    into layout.buildDirectory.dir( "documentation/integrationguide" )
}

def stageQuickstartTask = tasks.register( "stageQuickstart", Copy ) {
    group 'documentation'
    description "Stages the Getting Started Guide as part of assembling documentation in preparation for release"

    dependsOn ':documentation:renderGettingStartedGuides'

    from project.provider { project( ":documentation" ).layout.buildDirectory.dir( "asciidoc/quickstart" ) }
    into layout.buildDirectory.dir( "documentation/quickstart" )
}

def stageTopicalGuideTask = tasks.register( "stageTopicalGuide", Copy ) {
    group 'documentation'
    description "Stages the Topical Guide as part of assembling documentation in preparation for release"

    dependsOn ':documentation:renderTopicalGuides'

    from project.provider { project( ":documentation" ).layout.buildDirectory.dir( "asciidoc/topical" ) }
    into layout.buildDirectory.dir( "documentation/topical" )

}

def stageIntroductionGuideTask = tasks.register( "stageIntroductionGuide", Copy ) {
    group 'documentation'
    description "Stages the Introduction Guide as part of assembling documentation in preparation for release"

    dependsOn ':documentation:renderIntroductionGuides'

    from project.provider { project( ":documentation" ).layout.buildDirectory.dir( "asciidoc/introduction" ) }
    into layout.buildDirectory.dir( "documentation/introduction" )
}

def stageQueryGuideTask = tasks.register( "stageQueryGuide", Copy ) {
    group 'documentation'
    description "Stages the Query Language Guide as part of assembling documentation in preparation for release"

    dependsOn ':documentation:renderQueryLanguageGuides'

    from project.provider { project( ":documentation" ).layout.buildDirectory.dir( "asciidoc/querylanguage" ) }
    into layout.buildDirectory.dir( "documentation/querylanguage" )
}

def stageRepositoriesGuideTask = tasks.register( "stageRepositoriesGuide", Copy ) {
    group 'documentation'
    description "Stages the Repositories Guide as part of assembling documentation in preparation for release"

    dependsOn ':documentation:renderRepositories'

    from project.provider { project( ":documentation" ).layout.buildDirectory.dir( "asciidoc/repositories" ) }
    into layout.buildDirectory.dir( "documentation/repositories" )
}

def stageUserGuideTask = tasks.register( "stageUserGuide", Copy ) {
    group 'documentation'
    description "Stages the User Guide as part of assembling documentation in preparation for release"

    dependsOn ':documentation:renderUserGuides'

    from project.provider { project( ":documentation" ).layout.buildDirectory.dir( "asciidoc/userguide" ) }
    into layout.buildDirectory.dir( "documentation/userguide" )
}


def stageMigrationGuideTask = tasks.register( "stageMigrationGuide", Copy ) {
    group 'documentation'
    description "Stages the Migration Guide as part of assembling documentation in preparation for release"

    dependsOn ':documentation:renderMigrationGuide'

    from project.provider { project( ":documentation" ).layout.buildDirectory.dir( "asciidoc/migration-guide" ) }
    into layout.buildDirectory.dir( "documentation/migration-guide" )
}

def stageWhatsNewGuideTask = tasks.register( "stageWhatsNewGuide", Copy ) {
    group 'documentation'
    description "Stages the What's New guide as part of assembling documentation in preparation for release"

    dependsOn ':documentation:renderWhatsNew'

    from project.provider { project( ":documentation" ).layout.buildDirectory.dir( "asciidoc/whats-new" ) }
    into layout.buildDirectory.dir( "documentation/whats-new" )
}

tasks.named( "publishMigrationGuide" ).configure {
    dependsOn stageMigrationGuideTask
}

def stageIncubationReportTask = tasks.register( "stageIncubationReport", Copy ) { task ->
    group 'documentation'
    description "Stages ORM @Incubating report as part of assembling documentation in preparation for release"

    dependsOn ':documentation:generateIncubationReport'
    tasks.stageOrmReports.dependsOn task

    from project( ":documentation" ).tasks.generateIncubationReport
    into layout.buildDirectory.dir( "documentation/incubating" )
}

def stageInternalsReportTask = tasks.register( "stageInternalsReport", Copy ) { task ->
    group 'documentation'
    description "Stages the @Internal report as part of assembling documentation in preparation for release"

    dependsOn ':documentation:generateInternalsReport'

    from project( ":documentation" ).tasks.generateInternalsReport
    into layout.buildDirectory.dir( "documentation/internals" )
}

def stageDeprecationReportTask = tasks.register( "stageDeprecationReport", Copy ) {
    group 'documentation'
    description "Stages the @Deprecated/@Remove report as part of assembling documentation in preparation for release"

    dependsOn ':documentation:generateDeprecationReport'

    from project( ":documentation" ).tasks.generateDeprecationReport
    into layout.buildDirectory.dir( "documentation/deprecated" )
}

def stageLoggingReportTask = tasks.register( "stageLoggingReport", Copy ) { task ->
    group 'documentation'
    description "Stages the logging report as part of assembling documentation in preparation for release"

    dependsOn ':documentation:renderLoggingReport'

    from project( ":documentation" ).tasks.renderLoggingReport
    into layout.buildDirectory.dir( "documentation/logging" )
}

def stageDialectReportTask = tasks.register( "stageDialectReport", Copy ) { task ->
    group 'documentation'
    description "Stages the supported Dialects report as part of assembling documentation in preparation for release"

    dependsOn ':documentation:renderDialectReport'

    from project( ":documentation" ).tasks.renderDialectReport
    into project.layout.buildDirectory.dir("documentation/dialect")
}

def stageOrmReportsTask = tasks.register( "stageOrmReports" ) {
    group 'documentation'
    description "Stages all ORM reports as part of assembling documentation in preparation for release"

    dependsOn ':documentation:generateReports'
    dependsOn stageIncubationReportTask
    dependsOn stageInternalsReportTask
    dependsOn stageDeprecationReportTask
    dependsOn stageLoggingReportTask
    dependsOn stageDialectReportTask
}

def stageJavadocsTask = tasks.register( "stageJavadocs", Copy ) {
    group 'documentation'
    description "Stages the aggregated Javadocs as part of assembling documentation in preparation for release"

    dependsOn ':documentation:javadoc'

    from project( ":documentation" ).tasks.javadoc
    into project.layout.buildDirectory.dir("documentation/javadocs")
}

/**
 * Assembles all documentation into the {buildDir}/documentation directory.
 *
 * Depends on building the docs
 */
def assembleDocumentationTask = tasks.register( "assembleDocumentation" ) {
    group 'documentation'
    description 'Assembles all documentation into the {buildDir}/documentation directory'

    dependsOn ':documentation:buildDocsForPublishing'
    dependsOn stageJavadocsTask
    dependsOn stageQuickstartTask
    dependsOn stageIntroductionGuideTask
    dependsOn stageUserGuideTask
    dependsOn stageQueryGuideTask
    dependsOn stageRepositoriesGuideTask
    dependsOn stageIntegrationGuideTask
    dependsOn stageTopicalGuideTask
    dependsOn stageMigrationGuideTask
    dependsOn stageWhatsNewGuideTask
    dependsOn stageOrmReportsTask
}






// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Stage - Release Perform : see `releasePerform`
//
// This stage is all about publishing artifacts -
//      * On the `:release` project, this means uploading documentation
//      * On the `:hibernate-gradle-plugin` project, this means publishing to the Plugin Portal
//      * On the published java modules, this means publishing its artifacts to Sonatype
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

def uploadDocumentationTask = tasks.named( "uploadDocumentation" ) {
    group = "release-perform"
    description = "Uploads assembled documentation to the doc server"
    dependsOn assembleDocumentationTask

    doFirst {
        if ( ormBuildDetails.hibernateVersion.isSnapshot ) {
            logger.error( "Cannot perform upload of SNAPSHOT documentation" );
            throw new RuntimeException( "Cannot perform upload of SNAPSHOT documentation" );
        }
        else {
            logger.lifecycle( "Uploading documentation ..." )
        }
    }

    doLast {
        logger.lifecycle( 'Done uploading documentation' )
    }
}

tasks.register( 'releasePerform' ) {
    group = "release-perform"
    description "Scripted release 'Release Perform' stage"

    dependsOn uploadDocumentationTask
    dependsOn uploadDocumentationDescriptor

    doFirst {
        if ( ormBuildDetails.releaseDetails.shouldCreateTag() ) {
            assert project.gitRemote != null
            assert project.gitBranch != null
            assert project.ormBuildDetails.releaseDetails.tagNameToUse != null
        }
    }

    doLast {
        if ( ormBuildDetails.releaseDetails.shouldCreateTag() ) {
            logger.lifecycle( "Pushing branch and tag to remote `${project.gitRemote}`..." )
            executeGitCommand( 'push', '--atomic', project.gitRemote, project.gitBranch, project.ormBuildDetails.releaseDetails.tagNameToUse )
        }
        else {
            logger.lifecycle( "Pushing branch to remote `${project.gitRemote}`..." )
            executeGitCommand( 'push', project.gitRemote, project.gitBranch )
        }
    }
}





// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Utilities
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


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 String getVersionId(jsonReleaseNotes, String restReleaseVersion) {
        for ( def issue : jsonReleaseNotes.issues ) {
            for ( def fixVersion : issue.fields.fixVersions ) {
                if ( fixVersion.name == restReleaseVersion ) {
                    return fixVersion.id
                }
            }
        }
        throw new GradleException("No issues found for current release version (" + restReleaseVersion + "), aborting.")
    }
}

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