saker.build

global(VERSION_saker.jar) = "0.8.5"

global(saker.jar_DEPENDENCIES) = [
	saker.zip,
]

static(VERSION_saker.build) = nest.dependency.resolve(
	saker.build,
	Filters: nest.dependency.filter.kind([]),
)[Bundles][0][BundleIdentifier][VersionNumber]
static(VERSION_saker.nest) = nest.dependency.resolve(
	saker.nest,
	Filters: nest.dependency.filter.kind([]),
)[Bundles][0][BundleIdentifier][VersionNumber]

compile(
	out javac,
){
	$javac = saker.java.compile(
		SourceDirectories: [
			src/main/,
		],
		ClassPath: [
			saker.java.classpath.bundle([
				"saker.build-api-v{ static(VERSION_saker.build) }",
				"saker.nest-api-v{ static(VERSION_saker.nest) }"
			]),
			saker.java.classpath.bundle(nest.dependency.resolve(
				Bundles: global(saker.jar_DEPENDENCIES),
				Filters: nest.dependency.filter.compile(CompileTransitive: false)
			)),
		],
		Identifier: saker.jar,
		SourceVersion: 8,
		TargetVersion: 8,
		Parameters: [--release, 8]
	)
}
export(
	out compile = compile(),
	out jar,
	out sourcejar,
	
	out bundlepaths = [
		$jar[Path],
		$sourcejar[Path],
	]
){
	$jar = saker.jar.create(
		Output: saker.jar.jar,
		Resources: [
			{
				Directory: resources,
				Resources: **,
			},
			{
				Directory: $compile[javac][ClassDirectory],
				Resources: **,
			},
			{
				Files: LICENSE,
				TargetDirectory: META-INF,
			},
		],
		Manifest: {
			MainAttributes: {
				Nest-Bundle-Identifier: "saker.jar-v{ global(VERSION_saker.jar) }",
				Nest-Bundle-Source: "saker.jar-sources-v{ global(VERSION_saker.jar) }",
			},
		},
	)
	$sourcejar = saker.jar.create(
		Output: saker.jar-sources.jar,
		Resources: [
			{
				Directory: src/main/,
				Resources: **/*.java,
			},
			{
				Files: LICENSE,
				TargetDirectory: META-INF,
			},
		],
		Manifest: {
			MainAttributes: {
				Nest-Bundle-Format-Version: 1,
				Nest-Bundle-Identifier: "saker.jar-sources-v{ global(VERSION_saker.jar) }",
			},
		},
	)
}
install(
	out export = export()
){
	nest.local.install($export[bundlepaths])
}

test(){
	$export = export()
	$jar = $export[jar]
	
	$instrumentedjar = nest.test.instrument(
		nest.bundle.download("saker.build-test-v{ static(VERSION_saker.build) }")[BundlePaths][0],
		NestVersion: static(VERSION_saker.nest),
	)
	
	$jarpath = $jar[Path]
	$testcompile = saker.java.compile(
		SourceDirectories: src/test/,
		ClassPath: [
			$instrumentedjar,
			saker.java.classpath.bundle([
				"saker.build-test-runner-v{ static(VERSION_saker.build) }",
				"saker.build-test-utils-v{ static(VERSION_saker.build) }",
				"saker.nest-test-utils-v{ static(VERSION_saker.nest )}"
			]),
		],
		Identifier: saker.jar.tests,
	)
	$resolveddependencies = nest.dependency.resolve(
		Bundles: global(saker.jar_DEPENDENCIES),
		Filters: nest.dependency.filter.kind(classpath)
	)
	
	$bundlemirrorpathsarg = foreach $path in $export[bundlepaths]: "{ std.file.mirror($path) };" 
	
	saker.java.test(
		TestRunnerClassPath: [
			saker.java.classpath.bundle("saker.build-test-runner-v{ static(VERSION_saker.build) }"),
		],
		ClassPath: [
			$instrumentedjar,
		],
		DependencyClassPath: [
			$export[compile][javac],
		],
		TestInvokerClass: testing.saker.SakerJavaTestingInvoker,
		TestClassPath:	[
			$testcompile[ClassDirectory],
			saker.java.classpath.bundle([
				"saker.build-test-utils-v{ static(VERSION_saker.build) }",
				"saker.nest-test-utils-v{ static(VERSION_saker.nest )}",
			]),
		],
		TestClasses: [
			testing.saker.tests.**.*Test
		],
		NonDeterministicTests: [
			**,
		],
		TestClassParameters: {
			**: {
				RepositoryJarPath: nest.bundle.localize("saker.nest-test-v{ static(VERSION_saker.nest) }")[BundleLocalPaths][0],
				RepositoryParameterBundles: "{ $bundlemirrorpathsarg };{ 
						foreach $path in nest.bundle.localize($resolveddependencies)[BundleLocalPaths]: ";{ $path }"
					}",
			}
			**.OlderZipBundleCompatibilityTaskTest: {
				OlderZipBundles: "{ $bundlemirrorpathsarg };{
						foreach $path in nest.bundle.localize(nest.dependency.resolve(
								DependencyFile: test/resources/testcontents/testing/saker/tests/tasks/jar/create/OlderZipBundleCompatibilityTaskTest/dependencies,
								Filters: nest.dependency.filter.kind(classpath)
							))[BundleLocalPaths]: ";{ $path }"
					}" 
			}
		},
		TestInvokerParameters: {
			SakerJarPath: std.file.mirror($instrumentedjar),
			TimeoutMillis: 120000,
			TestsBaseBuildDirectory: std.file.mirror.path(std.file.place(test/build)),
		},
		IgnoreFileChanges: [
			std.file.place(test/build),
		] + $export[bundlepaths],
		ProcessJVMParameters: [ 
			#"-agentlib:jdwp=transport=dt_socket,address=localhost:5432,server=y,suspend=y,quiet=y"
			"-Xverify:all" # due to a crash that we encountered: fatal error: Illegal class file encountered. Try running with -Xverify:all in method parseClassValue
		],
		MaxJVMCount: 1,
		FailFast: true,
		AbortOnFail: true,
		Verbose: true,
	)
}