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 "8.4.0"
	// https://github.com/harbby/gradle-serviceloader
    id "com.github.harbby.gradle.serviceloader" version "1.1.9"
	// Shadow
	id "com.gradleup.shadow" version "9.4.1"
    // Download task
    id "de.undercouch.download" version "5.7.0"
}

/**
 * Project Properties
 */
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"
	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
	// if ( file( '../../boxlang/build/libs/boxlang-' + boxlangVersion + '.jar' ).exists() ) {
	// 	compileOnly files( '../../boxlang/build/libs/boxlang-' + boxlangVersion + '.jar' )
	// 	testImplementation files( '../../boxlang/build/libs/boxlang-' + boxlangVersion + '.jar' )
	// } else {
		compileOnly files( 'src/test/resources/libs/boxlang-' + boxlangVersion + '.jar' )
		testImplementation files( 'src/test/resources/libs/boxlang-' + boxlangVersion + '.jar' )
	//}

	// PDF Extraction
	implementation 'org.apache.pdfbox:pdfbox:3.0.7'

	// JSoup for HTML parsing and web scraping
	implementation 'org.jsoup:jsoup:1.22.1'

	// RSS Reader for feed parsing
	implementation 'com.apptasticsoftware:rssreader:3.12.0'

	// Testing Frameworks
	testImplementation 'io.github.cdimascio:dotenv-java:3.2.0'
	testImplementation "org.junit.jupiter:junit-jupiter:6.+"
	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 {
	// Replaces sourceCompatibility, targetCompatibility
	toolchain {
        languageVersion.set( JavaLanguageVersion.of( jdkVersion ) )
    }
    // Produces a javadocs jar
	withJavadocJar()
}

// Exclude main resources from IDE classpath to avoid class loading conflicts
// Resources are still included in the JAR/build outputs
sourceSets {
	main {
		resources {
			// Empty the resources to exclude from IDE classpath
			srcDirs = []
		}
	}
}

compileJava {
	// Compiler Options
	options.incremental = true
	options.encoding = 'UTF-8'
	options.debugOptions.debugLevel = "source,lines,vars"
}

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.jdbc.drivers.IJDBCDriver'
    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': 'ExampleBoxLangModule'
    }
}
shadowJar {
	archiveClassifier = ''
    mergeServiceFiles()
    destinationDirectory = file( "build/libs" )

	// Minimize the JAR by only including classes that are actually used
	// This significantly reduces the size by excluding unused PDFBox classes
	minimize {
		// Keep JSoup classes (used by WebCrawlerLoader)
		exclude( dependency( 'org.jsoup:.*' ) )
		// Keep RSS Reader classes (used by FeedLoader)
		exclude( dependency( 'com.apptasticsoftware:.*' ) )
		// Keep PDFBox classes (used by PDFLoader.bx - BoxLang files aren't analyzed by bytecode scanner)
		exclude( dependency( 'org.apache.pdfbox:.*' ) )
		// Keep FontBox classes (required by PDFBox for text extraction)
		exclude( dependency( 'org.apache.fontbox:.*' ) )
	}
}

/**
 * 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.jar to build/module/libs/BoxLangModuleTemplate-1.0.0.jar
 * - Copies the src/main/bx/** to build/module/ folder.
 */
task createModuleStructure(type: Copy) {
	mustRunAfter shadowJar, jar
    from( 'build/libs' ) {
		include "${project.name}-${version}.jar"
        into 'libs'
    }
    from( 'src/main/bx' ) {
		include '**/*.bx'
		include '**/*.bxm'
		include '**/*.bxs'
		// 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 ) }
		}
    }
    from( 'docs' ) {
        include '**/*.md'
        into 'docs'
    }

    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
        events "passed", "skipped", "failed"
        exceptionFormat "full"
        showExceptions true
        showCauses true
	}
	classpath = classpath.filter { !it.path.contains( "build${File.separator}resources" ) }
}

/**
 * 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"
    // Specify the destination directory for the downloaded file
    dest "src/test/resources/libs/boxlang-${boxlangVersion}.jar"
    overwrite true
    onlyIfModified false
}

/**
 * Task to download and extract the needed boxlang modules for testing.
 */
task downloadBoxLangModules( type: Download ) {
	// Create the destination directory
	doFirst {
		def modulesDir = file( "src/test/resources/modules" )
		// Delete the directory recursively first if it exists
		if ( modulesDir.exists() ) {
			modulesDir.deleteDir()
		}
		// Recreate it
		modulesDir.mkdirs()
	}
    // Download the test dependencies
    src( [
		"https://downloads.ortussolutions.com/ortussolutions/boxlang-modules/bx-derby/${derbyModuleVersion}/bx-derby-${derbyModuleVersion}.zip",
		"https://downloads.ortussolutions.com/ortussolutions/boxlang-modules/bx-postgresql/${postgresqlModuleVersion}/bx-postgresql-${postgresqlModuleVersion}.zip",
		"https://downloads.ortussolutions.com/ortussolutions/boxlang-modules/bx-sqlite/${sqliteModuleVersion}/bx-sqlite-${sqliteModuleVersion}.zip",
		"https://downloads.ortussolutions.com/ortussolutions/boxlang-modules/bx-mysql/${mysqlModuleVersion}/bx-mysql-${mysqlModuleVersion}.zip",
		"https://downloads.ortussolutions.com/ortussolutions/boxlang-modules/bx-web-support/${webSupportVersion}/bx-web-support-${webSupportVersion}.zip"
	] )
    // Specify the destination for the downloaded file
    dest "src/test/resources/modules/"
    overwrite true
    onlyIfModified false
}

task extractBoxLangModules( type: Copy ) {
	dependsOn downloadBoxLangModules
	from( zipTree( "src/test/resources/modules/bx-derby-${derbyModuleVersion}.zip" ) ) {
		into "bx-derby"
	}
	from( zipTree( "src/test/resources/modules/bx-postgresql-${postgresqlModuleVersion}.zip" ) ) {
		into "bx-postgresql"
	}
	from( zipTree( "src/test/resources/modules/bx-sqlite-${sqliteModuleVersion}.zip" ) ) {
		into "bx-sqlite"
	}
	from( zipTree( "src/test/resources/modules/bx-mysql-${mysqlModuleVersion}.zip" ) ) {
		into "bx-mysql"
	}
	from( zipTree( "src/test/resources/modules/bx-web-support-${webSupportVersion}.zip" ) ) {
		into "bx-web-support"
	}
	destinationDir = file( "src/test/resources/modules" )
}

// Make sure test depends on Derby module extraction
downloadBoxLang.finalizedBy( extractBoxLangModules )

/**
 * 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}.0"
	} else if( major ){
		newVersion = "${newPathVersion}.0.0"
	}

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