saker.build

global(VERSION_sipka.jvm.tailrec) = "0.8.2"

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]

static(VERSION_sipka.cmdline) = "0.8.3"

static(TEST_COMPILER_OPTIONS) = [
	{
		Identifier: jdk8,
		SourceDirectories: test/src-jdk8/
	}
]

compile(
	out javac
) {
	$javac = saker.java.compile(
		src,
		AnnotationProcessors: {
			Processor: saker.java.processor.bundle(
				Bundle: "sipka.cmdline-processor-v{ static(VERSION_sipka.cmdline) }",
				Class: sipka.cmdline.processor.CommandLineProcessor,
				Aggregating: false,				
			),
			SuppressWarnings: [ 
				LastRoundGeneration,
			],
		},
		ClassPath: [
			saker.java.classpath.bundle("sipka.cmdline-api-v{ static(VERSION_sipka.cmdline) }"),
			saker.java.classpath.bundle("sipka.cmdline-runtime-v{ static(VERSION_sipka.cmdline) }"),
			saker.java.classpath.bundle(nest.dependency.resolve(
				Bundles: [saker.build-api, saker.nest-api],
				DependencyFile: resources/META-INF/nest/dependencies,
				Filters: nest.dependency.filter.compile(CompileTransitive: false),
			))
		],
	)
}

export(
	in compile = include(compile),
	out compile,
	
	out jar,
	out sourcejar,
	
	out bundlepaths = [
		$jar[Path],
		$sourcejar[Path],
	]
){
	$jar = saker.jar.create(
		Output: sipka.jvm.tailrec.jar,
		Resources: [
			{
				Directory: $compile[javac][ClassDirectory],
				Resources: **,
			},
			{
				Files: LICENSE,
				TargetDirectory: META-INF,
			},
			{
				Directory: resources/,
				Resources: **,
			}
		],
		Includes: [
			{
				Archive: nest.bundle.download("sipka.cmdline-runtime-v{ static(VERSION_sipka.cmdline) }")[BundlePaths][0],
				Resources: sipka/cmdline/runtime/**/*.class,
			},
		],
		Manifest: {
			MainAttributes: {
				Main-Class: sipka.jvm.tailrec.Main,
				Nest-Bundle-Format-Version: 1,
				Nest-Bundle-Identifier: "sipka.jvm.tailrec-v{ global(VERSION_sipka.jvm.tailrec) }",
				Nest-Bundle-Source: "sipka.jvm.tailrec-sources-v{ global(VERSION_sipka.jvm.tailrec) }"
			}
		}
	)
	$sourcejar = saker.jar.create(
		Output: sipka.jvm.tailrec-sources.jar,
		Resources: [
			{
				Directory: [
					src/,
				],
				Resources: **/*.java,
			},
			{
				Files: LICENSE,
				TargetDirectory: META-INF,
			}
		],
		Manifest: {
			MainAttributes: {
				Nest-Bundle-Format-Version: 1,
				Nest-Bundle-Identifier: "sipka.jvm.tailrec-sources-v{ global(VERSION_sipka.jvm.tailrec) }",
			},
		},
	)
}
install() {
	$export = include(export)
	nest.local.install(Bundle: $export[bundlepaths])
}
upload(){
	$export = include(export, Path: saker.build)
	include(Path: secret/secrets.build)
	nest.server.upload(
		Bundles: $export[bundlepaths],
		APIKey: global(sipka.jvm.tailrec.UPLOAD_API_KEY),
		APISecret: global(sipka.jvm.tailrec.UPLOAD_API_SECRET),
		Overwrite: true,
	)
}
test_on_jdk(
	in jdk_version = 8,
	
	out export
	out compile,
	out testcompile,
	out instrumentedjar,
) {
	$export = include(export)
	$compile = $export[compile]
	
	$instrumentedjar = nest.test.instrument(
		nest.bundle.download("saker.build-test-v{ static(VERSION_saker.build) }")[BundlePaths][0],
		NestVersion: static(VERSION_saker.nest),
	)
	
	$testcompile = saker.java.compile(
		SourceDirectories: test/src/,
		ClassPath: [
			$compile[javac][ClassDirectory],
			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 )}",
			]),
			$instrumentedjar
		],
		SourceVersion: "RELEASE_{$jdk_version}",
		TargetVersion: "RELEASE_{$jdk_version}",
		Identifier: "tests-jdk{$jdk_version}",
		CompilerOptions: static(TEST_COMPILER_OPTIONS)
	)
	
	saker.java.test(
		TestRunnerClassPath: [
			saker.java.classpath.bundle("saker.build-test-runner-v{ static(VERSION_saker.build) }"),
		],
		ClassPath: $compile[javac],
		TestInvokerClass: testing.saker.SakerJavaTestingInvoker,
		TestClassPath: [
			$testcompile[ClassDirectory],
			saker.java.classpath.bundle([
				"saker.build-test-utils-v{ static(VERSION_saker.build) }",
			]),
		],
		TestClasses: [
			testing.sipka.**.*Test
		],
		#ProcessJVMParameters: [ "-agentlib:jdwp=transport=dt_socket,address=localhost:5432,server=y,suspend=y,quiet=y" ],
		NonDeterministicTests: **,
		TestInvokerParameters: {
			TimeoutMillis: 60000,
		},
		MaxJVMCount: 1,
		FailFast: true,
		AbortOnFail: true,
		Verbose: true,
	)
}

test() {
	test_on_jdk(jdk_version: 5)
	test_on_jdk(jdk_version: 6)
	test_on_jdk(jdk_version: 7)
	
	# use results from jdk 8 test for saker.build task tests
	$jdk8test = test_on_jdk(jdk_version: 8)
	
	$testcompile = $jdk8test[testcompile]
	$compile = $jdk8test[compile]
	$export = $jdk8test[export]
	$instrumentedjar = $jdk8test[instrumentedjar]
	
	$resolveddependencies = nest.dependency.resolve(
		Bundles: [saker.zip, saker.java.compiler, saker.jar],
		DependencyFile: resources/META-INF/nest/dependencies,
		Filters: nest.dependency.filter.kind(classpath)
	)
	
	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.sipka.**.*Test
		],
		NonDeterministicTests: [
			**,
		],
		TestClassParameters: {
			**: {
				RepositoryJarPath: nest.bundle.localize("saker.nest-test-v{ static(VERSION_saker.nest) }")[BundleLocalPaths][0],
				RepositoryParameterBundles: "{
						foreach $path in $export[bundlepaths]: "{ std.file.mirror($path) };" 
					};{ 
						foreach $path in nest.bundle.localize($resolveddependencies)[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),
		],
		MaxJVMCount: 1,
		FailFast: true,
		AbortOnFail: true,
		Verbose: true,
	)
}