build.gradle

// 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 "6.25.0"
	// https://github.com/harbby/gradle-serviceloader
    id "com.github.harbby.gradle.serviceloader" version "1.1.8"
	// For building shadow jars with jdk 17 ONLY
    //id 'com.github.johnrengelman.shadow' version '8.1.1'
    // For building shadow jars using JDK 21 +, they had to fork
    id "io.github.goooler.shadow" version "8.1.8"
    // Download task
    id "de.undercouch.download" version "5.6.0"
}

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

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"
	boxlangVersion = boxlangVersion.contains('-') ? boxlangVersion.replaceAll(/-.*/, '-snapshot') : "${boxlangVersion}-snapshot"
}

repositories {
    mavenLocal()
    mavenCentral()
}

dependencies {
	// Until BoxLang is published to Maven Central
	// Look for it in the local build directory
	// You must run `./gradle build -x test` in the BoxLang project
	compileOnly files( '../../boxlang/build/distributions/boxlang-' + boxlangVersion + '-all.jar' )
    compileOnly files( 'src/test/resources/libs/boxlang-' + boxlangVersion + '-all.jar' )

	// Implementation Dependencies
	// IMPORTANT: If updating Hibernate, please change the static version number in `src/main/java/ortus/boxlang/modules/orm/bifs/GetHibernateVersion.java` to match.
	// https://mvnrepository.com/artifact/org.hibernate.orm/hibernate-core
	implementation 'org.hibernate:hibernate-core:5.6.15.Final'
	// https://mvnrepository.com/artifact/org.hibernate/hibernate-jcache
	implementation 'org.hibernate:hibernate-jcache:5.6.15.Final'
	// https://mvnrepository.com/artifact/javax.cache/cache-api
	implementation 'javax.cache:cache-api:1.1.1'
	// https://mvnrepository.com/artifact/org.ehcache/ehcache
	implementation 'org.ehcache:ehcache:3.10.8'

    // Testing Dependencies
	testImplementation files( '../../boxlang/build/distributions/boxlang-' + boxlangVersion + '-all.jar' )
	testImplementation files( 'src/test/resources/libs/boxlang-' + boxlangVersion + '-all.jar' )
    testImplementation "org.junit.jupiter:junit-jupiter:5.+"
	testImplementation "org.mockito:mockito-core:5.+"
	testImplementation "com.google.truth:truth:1.+"
}

java {
    // Produces a javadocs jar
	withJavadocJar()
}

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

compileTestJava{
	// Make sure the service loaders are created before testing
	dependsOn compileJava, serviceLoaderBuild
}
compileTestJava.finalizedBy( shadowJar )

/**
 * Clean up
 */
clean {
	doLast{
		var userDir = file( "${System.getProperty('user.home')}/.boxlang/classes" )
		if ( userDir.exists() ) {
			userDir.deleteDir()
			println "+ Cleared user home classes " + userDir.toString()
		}
		println "+ Clean finalized!"
	}
}

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 )

/**
 * 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'
	serviceInterface 'ortus.boxlang.runtime.services.IService'
}

jar {
    archiveVersion =  "${version}"
 	manifest {
	   attributes 'Description': 'BoxLang ORM'
    }
}
shadowJar {
    mergeServiceFiles()
    destinationDirectory = file( "build/libs" )
}
build.finalizedBy( shadowJar )

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

/**
 * Custom task that creates a build/module folders
 * - Copies the build/libs/BoxLangModuleTemplate-1.0.0-all.jar to build/module/libs/BoxLangModuleTemplate-1.0.0-all.jar
 * - Copies the src/main/bx/** to build/module/ folder.
 */
task createModuleStructure(type: Copy) {
    from( 'build/libs' ) {
		include "${project.name}-${version}-all.jar"
        into 'libs'
    }
    from( 'src/main/bx' ) {
		include '**/*.bx'
		// Token Replacements Go Here
		filter { line -> line.replaceAll('@build.version@', project.version) }
		if( project.branch == "development" ){
			filter { line -> line.replaceAll( '\\+@build.number@', '' ) }
		} else {
			filter { line -> line.replaceAll( '@build.number@', project.buildID ) }
		}
    }
    from( '.' ) {
        include 'box.json'
		include 'readme.md'
		include 'changelog.md'
		// Token Replacements Go Here
		filter { line -> line.replaceAll( '@build.version@', project.version ) }
		if( project.branch == "development" ){
			filter { line -> line.replaceAll( '\\+@build.number@', '' ) }
		} else {
			filter { line -> line.replaceAll( '@build.number@', project.buildID ) }
		}
    }

    destinationDir = file( 'build/module' )
}
task zipModuleStructure( type: Zip ) {
    group "distribution"
    from createModuleStructure.destinationDir
    archiveFileName = "${project.name}-${version}.zip"
    destinationDirectory = file( "$buildDir/distributions" )
    // Output that the module has been zippped
    doLast {
        println "+ Module has been zipped to the distribution folder"
    }
}
createModuleStructure.finalizedBy( zipModuleStructure )
shadowJar.finalizedBy( createModuleStructure )

test {
	useJUnitPlatform()
	testLogging {
		showStandardStreams = true
	}
	classpath = classpath.filter { !it.path.contains('/build/resources') }
}

/**
 * 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-all.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}-all.jar",
		"https://downloads.ortussolutions.com/ortussolutions/boxlang-modules/bx-mysql/${mysqlVersion}/bx-mysql-${mysqlVersion}.zip"
	])
    // Specify the destination directory for the downloaded files
    dest "src/test/resources/libs/"
    overwrite true
    onlyIfModified false
}

/**
 * Install any dependencies the module needs
 */
task installModuleDependencies( dependsOn: downloadBoxLang, type: Copy ) {
	from zipTree( file( "${testResourceDirectory}/libs/bx-mysql-${mysqlVersion}.zip" ) )
	into "${testResourceDirectory}/modules/bx-mysql"
}

/**
 * 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 ->

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

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

	def currentVersion = properties.getProperty( 'version' )
	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}.${versionParts[ 2 ]}"
	} else if( major ){
		newVersion = "${newPathVersion}.${versionParts[ 1 ]}.${versionParts[ 2 ]}"
	}

	properties.setProperty( 'version', newVersion )
	properties.store( propertiesFile.newWriter(), null )

	println "Bumped version from ${currentVersion} to ${newVersion}"
}
/**
 * Bump the major version number
 */
task bumpMajorVersion {
	doLast{
		bumpVersion( true )
	}
}

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

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