build.gradle

import java.nio.file.StandardCopyOption
import java.nio.file.Files
import java.text.SimpleDateFormat
import java.util.Date

// https://docs.gradle.org/current/userguide/building_java_projects.html#sec:java_packaging
plugins {
    id 'java'
    // For source code formatting
    id "com.diffplug.spotless" version "7.0.3"
	// https://github.com/harbby/gradle-serviceloader
    id "com.github.harbby.gradle.serviceloader" version "1.1.9"
	// Shadow
	id "com.gradleup.shadow" version "9.0.0-beta13"
    // Download task
    id "de.undercouch.download" version "5.6.0"
	// Task visualizer
	id "com.dorongold.task-tree" version "4.0.1"
	// Maven Publisher
	id 'maven-publish'
	id 'signing'
	id 'com.gradleup.nmcp' version "0.0.9"
}

/**
 * Project Properties
 */
sourceCompatibility = jdkVersion
targetCompatibility = jdkVersion
ext {
	buildID = System.getenv( 'BUILD_ID' ) ?: '0'
	branch = System.getenv( 'BRANCH' ) ?: 'development'
}

if (branch == 'development') {
    // If the branch is 'development', ensure the version ends with '-snapshot'
    // This replaces any existing prerelease identifier with '-snapshot'
    version = version.contains('-') ? version.replaceAll(/-.*/, '-snapshot') : "${version}-snapshot".toString()
	boxlangVersion = boxlangVersion.contains('-') ? boxlangVersion.replaceAll(/-.*/, '-snapshot') : "${boxlangVersion}-snapshot".toString()
}

repositories {
    mavenLocal()
    mavenCentral()
}

dependencies {
	// LOCAL DEVELOPMENT ONLY
	// CHOOSE THE RIGHT LOCATION FOR YOUR LOCAL DEPENDENCIES
  if ( file( '../boxlang/build/libs/boxlang-' + boxlangVersion + '.jar' ).exists() ) {
		implementation files( '../boxlang/build/libs/boxlang-' + boxlangVersion + '.jar' )
		implementation files( '../boxlang-web-support/build/distributions/boxlang-web-support-' + boxlangVersion + '.jar' )
	} else {
		// Downloaded Dependencies
		implementation files( 'src/test/resources/libs/boxlang-web-support-' + boxlangVersion + '.jar' )
		implementation files( 'src/test/resources/libs/boxlang-' + boxlangVersion + '.jar' )
	}

	// Downloaded Dependencies
	implementation 'com.amazonaws:aws-lambda-java-core:1.3.0'
    implementation 'org.slf4j:slf4j-nop:2.0.17'

    // Testing Dependencies
	// Pin this for now as there is a problem finding the tests with 5.11.4
    testImplementation "org.junit.jupiter:junit-jupiter:5.+"
	testImplementation "org.mockito:mockito-core:5.+"
	testImplementation "com.google.truth:truth:1.+"
	// Explicitly declare the JUnit platform launcher (to avoid deprecation)
    testRuntimeOnly "org.junit.platform:junit-platform-launcher"
}

java {
	withJavadocJar()
	withSourcesJar()
}

compileJava {
	// Compiler Options
	options.incremental = true
	options.encoding = 'UTF-8'
	options.debug()
}

compileTestJava {
	source sourceSets.test.java
	dependsOn compileJava, serviceLoaderBuild
	options.encoding = 'UTF-8'
}

jar {
    archiveVersion =  "${version}"
 	manifest {
		attributes 'Description': 'The BoxLang AWS Lambda Runtime'
		attributes 'Implementation-Version': "${version}+${buildID}"
		attributes 'Created-On': new SimpleDateFormat( "yyyy-MM-dd HH:mm:ss" ).format( new Date() )
		attributes 'Created-By': "Ortus Solutions, Corp"
    }
}
shadowJar {
	archiveClassifier = ""
    destinationDirectory = file( "build/distributions" )
	mergeServiceFiles()
	exclude "io/undertow/**"
	exclude "org/jboss/**"
	exclude "org/wildfly/**"
	exclude "org/xnio/**"
	exclude "org/antlr/v4/gui/**"
	exclude "org/antlr/v4/gui/**"
}
build.finalizedBy( shadowJar )

/**
 * Generate checksums for the given file using the specified algorithm

 * @param file The file to generate the checksum for
 * @param algorithm The algorithm to use (e.g., "SHA-256", "MD5")
 */
def generateChecksum( File file, String algorithm ) {
	def digest = java.security.MessageDigest.getInstance( algorithm )
	file.eachByte( 4096 ) { bytes, size ->
		digest.update( bytes, 0, size )
	}
	def checksum = digest.digest().collect { String.format( '%02x', it ) }.join()

	def checksumFile = new File( file.parent, "${file.name}.${algorithm.toLowerCase()}" )
	checksumFile.text = "${checksum}  ${file.name}\n"
}

/**
 * Publish the artifacts to the local maven repository
 */
publishing {
    publications {
        shadow( MavenPublication ) { publication ->
			artifact shadowJar
			artifact javadocJar
			artifact sourcesJar

			// This is the only one sonatype accepts, not ortus.boxlang
			// https://central.sonatype.com/
			groupId = 'io.boxlang'
			artifactId = 'boxlang-aws-lambda'
			pom {
				name = "BoxLang AWS Lambda Runtime"
				description = "BoxLang is a dynamic multi-runtime JVM Language based on fluency and functional constructs. This is the AWS Lambda Runtime for BoxLang."
				url = "https://boxlang.io"
				issueManagement {
					system = "Jira"
					url = "https://ortussolutions.atlassian.net/jira/software/c/projects/BL/issues"
				}
				mailingLists {
					mailingList {
						name = "BoxLang Community"
						subscribe = "https://community.ortussolutions.com/c/boxlang/42"
						unsubscribe = "https://community.ortussolutions.com/c/boxlang/42"
					}
				}
				licenses {
					license {
						name = 'The Apache License, Version 2.0'
						url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
					}
				}
				scm {
					connection = 'scm:git:https://github.com/ortus-boxlang/boxlang-aws-lambda.git'
					developerConnection = 'scm:git:ssh://github.com/ortus-boxlang/boxlang-aws-lambda.git'
					url = 'https://github.com/ortus-boxlang/boxlang-aws-lambda'
				}
				developers{
					developer {
						id  = "lmajano"
						name = "Luis Majano"
						email = "lmajano@ortussolutions.com"
						organization = "Ortus Solutions, Corp"
						organizationUrl = "https://www.ortussolutions.com"
					}
					developer {
						id = "bdw429s"
						name = "Brad Wood"
						email = "brad@ortussolutions.com"
						organization = "Ortus Solutions, Corp"
						organizationUrl = "https://www.ortussolutions.com"
					}
					developer {
						id = "jclausen"
						name = "Jon Clausen"
						email = "jclausen@ortussolutions.com"
						organization = "Ortus Solutions, Corp"
						organizationUrl = "https://www.ortussolutions.com"
					}
					developer {
						id = "michaelborn"
						name = "Michael Born"
						email = "michael@ortussolutions.com"
						organization = "Ortus Solutions, Corp"
						organizationUrl = "https://www.ortussolutions.com"
					}
					developer {
						id = "garciadev"
						name = "Daniel Garcia"
						email = "dgarcia@ortussolutions.com"
						organization = "Ortus Solutions, Corp"
						organizationUrl = "https://www.ortussolutions.com"
					}
					developer {
						id = "jbeers"
						name = "Jacob Beers"
						email = "jbeers@ortussolutions.com"
						organization = "Ortus Solutions, Corp"
						organizationUrl = "https://www.ortussolutions.com"
					}
					developer {
						id = "gpickin"
						name = "Gavin Pickin"
						email = "gavin@ortussolutions.com"
						organization = "Ortus Solutions, Corp"
						organizationUrl = "https://www.ortussolutions.com"
					}
					developer {
						id = "ericpeterson"
						name = "Eric Peterson"
						email = "eric@ortussolutions.com"
						organization = "Ortus Solutions, Corp"
						organizationUrl = "https://www.ortussolutions.com"
					}
				}
			}
        }
    }

    repositories {
        maven {
            name = 'local-repo'
            url = layout.buildDirectory.dir( "repo" )
        }
		maven {
			name = "GitHubPackages"
			url = "https://maven.pkg.github.com/ortus-boxlang/boxlang-aws-lambda"
			credentials {
				username = System.getenv( "GITHUB_ACTOR" )
				password = System.getenv( "GITHUB_TOKEN" )
			}
		}
    }
}

nmcp {
  publishAllProjectsProbablyBreakingProjectIsolation {
    username = System.getenv( "MAVEN_USERNAME" ) ?: project.findProperty( "maven_username" )
    password = System.getenv( "MAVEN_PASSWORD" ) ?: project.findProperty( "maven_password" )
    // publish manually from the portal
    //publicationType = "USER_MANAGED"
    // or if you want to publish automatically
    publicationType = "AUTOMATIC"
  }
}

/**
 * Digital Signing of assets
 */
signing {
	def signingKey = System.getenv("GPG_KEY") ?: project.findProperty("signing.keyId")
	def signingPassword = System.getenv("GPG_PASSWORD") ?: project.findProperty("signing.password")
    useInMemoryPgpKeys(signingKey, signingPassword)
    sign publishing.publications.shadow
}

/**
 * Docs are here:
 * - https://github.com/harbby/gradle-serviceloader,
 * - https://plugins.gradle.org/plugin/com.github.harbby.gradle.serviceloader
 * This generates the META-INF/services files for the ServiceLoader as part of the `build` task
 */
serviceLoader {
    serviceInterface 'ortus.boxlang.runtime.bifs.BIF'
    serviceInterface 'ortus.boxlang.runtime.components.Component'
    serviceInterface 'ortus.boxlang.runtime.async.tasks.IScheduler'
    serviceInterface 'ortus.boxlang.runtime.cache.providers.ICacheProvider'
	serviceInterface 'ortus.boxlang.runtime.events.IInterceptor'
}

/**
 * Token Replacements for files
 */
import org.apache.tools.ant.filters.ReplaceTokens
processResources {
	// Replace @build.date@ with the current date in META-INF/version.properties file
	filter( ReplaceTokens, tokens: [ 'build.date': new SimpleDateFormat( "yyyy-MM-dd HH:mm:ss" ).format( new Date() ) ] )
	// Replace @build.version@ with the current version in META-INF/version.properties file
	filter( ReplaceTokens, tokens: [ 'build.version': version + "+" + buildID ] )
}

javadoc {
    // To avoid our own doclet issues
	options.addBooleanOption( "Xdoclint:none", true )
	//exclude '**/boxlang/parser/**'
	options.addBooleanOption( 'html5', true )
}
task zipJavadocs( type: Zip ) {
	group "documentation"
	from javadoc.destinationDir
	archiveFileName = "${project.name}-javadocs-${version}.zip"
	destinationDirectory = file( "$buildDir/distributions" )
	// Output that the docs have been zippped
	doLast {
		println "+ Javadocs have been zipped to the distribution folder"
	}
}
javadoc.finalizedBy( zipJavadocs )

/**
 * Source Code Formatting
 */
spotless {
    java {
		target fileTree( "." ) {
            include "**/*.java"
            exclude "**/build/**", "bin/**", "examples/**"
        }
        eclipse().configFile( "./.ortus-java-style.xml" )
		toggleOffOn()
    }
}

task buildTestZip( type: Zip ) {
	archiveFileName = "${project.name}-test-${version}.zip"
	from 'src/test/resources/Lambda.bx'
	into( 'lib' ) {
		from shadowJar.outputs.files
	}
}
shadowJar.finalizedBy( buildTestZip )

task buildMainZip( type: Zip ) {
	archiveFileName = "${project.name}-${version}.zip"
	from 'src/main/resources/Lambda.bx'
	into( 'lib' ) {
		from shadowJar.outputs.files
	}

	doLast {
		// Generate checksums for all zip and jar files in distributions folder
		file( "build/distributions" ).listFiles().each { file ->
			if ( file.name.endsWith( '.zip' ) || file.name.endsWith( '.jar' ) ) {
				generateChecksum( file, 'SHA-256' )
				generateChecksum( file, 'MD5' )
			}
		}

		file( "build/evergreen" ).mkdirs()
		if( branch == 'development' ){
			Files.copy( file( "build/distributions/boxlang-aws-lambda-${version}.jar" ).toPath(), file( "build/evergreen/boxlang-aws-lambda-snapshot.jar" ).toPath(), StandardCopyOption.REPLACE_EXISTING )
			// Checksums
			Files.copy( file( "build/distributions/boxlang-aws-lambda-${version}.jar.sha-256" ).toPath(), file( "build/evergreen/boxlang-aws-lambda-snapshot.jar.sha-256" ).toPath(), StandardCopyOption.REPLACE_EXISTING )
			Files.copy( file( "build/distributions/boxlang-aws-lambda-${version}.jar.md5" ).toPath(), file( "build/evergreen/boxlang-aws-lambda-snapshot.jar.md5" ).toPath(), StandardCopyOption.REPLACE_EXISTING )
		} else {
			Files.copy( file( "build/distributions/boxlang-aws-lambda-${version}.jar" ).toPath(), file( "build/evergreen/boxlang-aws-lambda-latest.jar" ).toPath(), StandardCopyOption.REPLACE_EXISTING )
			Files.copy( file( "build/distributions/boxlang-aws-lambda-${version}.jar.sha-256" ).toPath(), file( "build/evergreen/boxlang-aws-lambda-latest.jar.sha-256" ).toPath(), StandardCopyOption.REPLACE_EXISTING )
			Files.copy( file( "build/distributions/boxlang-aws-lambda-${version}.jar.md5" ).toPath(), file( "build/evergreen/boxlang-aws-lambda-latest.jar.md5" ).toPath(), StandardCopyOption.REPLACE_EXISTING )
		}

		println "+ Main Zip has been created"
	}
}
shadowJar.finalizedBy( buildMainZip )

test {
    useJUnitPlatform()
    testLogging {
		showStandardStreams = true
	}
}

/**
 * TEMPORARY until we publish to maven
 * Task to download the latest jar from https://ortus-temp.s3.amazonaws.com/jericho/libs/boxlang-1.0.0.jar
 */
task downloadBoxLang( type: Download ) {
	// Create the destination directory
	doFirst {
		file( "src/test/resources/libs" ).mkdirs()
	}
    // Configure the URL of the file to download
    src([
		"https://downloads.ortussolutions.com/ortussolutions/boxlang/${boxlangVersion}/boxlang-${boxlangVersion}.jar",
		"https://downloads.ortussolutions.com/ortussolutions/boxlang-runtimes/boxlang-web-support/${boxlangVersion}/boxlang-web-support-${boxlangVersion}.jar"
	])
    // Specify the destination directories for the downloaded files
	dest "src/test/resources/libs/"
    overwrite true
    onlyIfModified false
}

/**
 * Project Wide Helper function
 * This is not a task, but a reusable UDF
 */
project.ext.bumpVersion = {
	boolean major = false,
	boolean minor = false,
	boolean patch = false,
	boolean beta = false,
	boolean rc = false,
	property = "version" ->

	def propertiesFile = file( './gradle.properties' );
	def properties = new Properties();

	properties.load( propertiesFile.newDataInputStream() )
	def versionTarget = major ? 0 : minor ? 1 : beta ? 2 : 3

	def currentVersion = properties.getProperty( property )
	def versionParts = currentVersion.split( '\\.' )
	def newPathVersion = versionParts[ versionTarget ].toInteger() + 1
	def newVersion = '';

	if( patch ){
		newVersion = "${versionParts[ 0 ]}.${versionParts[ 1 ]}.${newPathVersion}"
	} else if( minor ){
		newVersion = "${versionParts[ 0 ]}.${newPathVersion}.0"
	} else if( major ){
		newVersion = "${newPathVersion}.0.0"
	} else if( beta ){
		// Get's the -betaX version.
		def betaString = currentVersion.split( '-' )[ 1 ]
		// Now we get the beta number
		def betaNumber = betaString.split( 'beta' )[ 1 ].toInteger() + 1
		newVersion = currentVersion.split( '-' )[ 0 ] + "-beta${betaNumber}"
	} else if( rc ){
		newVersion = "${versionParts[ 0 ]}.${versionParts[ 1 ]}.${versionParts[ 2 ]}.${newPathVersion}"
	}

	properties.setProperty( property, newVersion )
	properties.store( propertiesFile.newWriter(), null )

	println "Bumped version from ${currentVersion} to ${newVersion}"
}

/**
 * Bump the major version number
 */
task bumpMajorVersion {
	doLast{
		bumpVersion( true, false, false, false, false, "version" )
		bumpVersion( true, false, false, false, false, "boxlangVersion" )
	}
}

/**
 * Bump the minor version number
 */
task bumpMinorVersion {
	doLast{
		bumpVersion( false, true, false, false, false, "version" )
		bumpVersion( false, true, false, false, false, "boxlangVersion" )
	}
}

/**
 * Bump the patch version number
 */
task bumpPatchVersion {
	doLast{
		bumpVersion( false, false, true, false, false, "version" )
		bumpVersion( false, false, true, false, false, "boxlangVersion" )
	}
}

/**
 * Bump the beta version number
 */
task bumpBetaVersion {
	doLast{
		bumpVersion( false, false, false, true, false, "version" )
		bumpVersion( false, false, false, true, false, "boxlangVersion" )
	}
}

/**
 * Bump the rc version number
 */
task bumpRCVersion {
	doLast{
		bumpVersion( false, false, false, false, true, "version" )
		bumpVersion( false, false, false, false, true, "boxlangVersion" )
	}
}