build.gradle

plugins {
	id 'base'
	id 'java'
	id 'com.github.node-gradle.node'
}

repositories {
	mavenCentral()
	gradlePluginPortal()
}

dependencies {
	// Use JUnit test framework.
	testImplementation 'junit:junit:4.13.2'
	
	// This dependency is used by the application. 
	implementation 'biz.aQute.bnd.workspace:biz.aQute.bnd.workspace.gradle.plugin:6.4.0'
}

java {
	toolchain {
		languageVersion = JavaLanguageVersion.of(project.java_source as Integer)
	}
}

/*
 * Setup multi-projects: 
 * - setup bnd tasks
 * - disable report generation
 * - setup parrallel execution
 */
subprojects {
	repositories {
		mavenCentral()
	}
	
	tasks.withType(JavaCompile) {
		options.release.set(project.java_target as Integer)
		options.encoding = 'UTF-8'
		options.fork = true
		options.incremental = true
	}
	
	tasks.withType(Test) {
		maxParallelForks = 2
		reports {
			html.required = false
			junitXml.required = false
		}
	}
	
	if (plugins.hasPlugin("biz.aQute.bnd")) {
		apply plugin: 'checkstyle'
		apply plugin: 'jacoco'
		
		jacocoTestReport {
			reports {
				xml.required = true
				csv.required = false
				html.required = false
			}
			// Exclude com.dalsemi.onewire
			afterEvaluate {
				classDirectories.setFrom(files(classDirectories.files.collect {
					fileTree(dir: it, excludes: ['**/com/dalsemi/onewire/**'])
				}))
			}
		}
	
		checkstyle {
			toolVersion = '10.11.0'
			configFile = file("${rootDir}/cnf/checkstyle.xml")
			maxWarnings = 0
			ignoreFailures = false
		}
	
		tasks.withType(Checkstyle) {
			reports {
				xml.required = false
				html.required = false
				sarif.required = false
			}
			minHeapSize = "512m"
			maxHeapSize = "2048m"
			// Exclude com.dalsemi.onewire
			exclude '**/com/dalsemi/onewire/*'
		}
	}
}

tasks.named('wrapper') {
	jarFile = rootProject.file('.gradle-wrapper/gradle-wrapper.jar')
}

task cleanEdge() {
	group 'OpenEMS-Build'
	description 'Clean all Edge-Bundles'
	
	subprojects.each { proj ->
		if( proj.name ==~ /io.openems.(common|edge|oem|shared|wrapper).*/ ) {
			if (proj.tasks.findAll { it.name == 'clean' }) {
				dependsOn(proj.clean)
			}
		}
	}
}

task checkstyleAll() {
	group 'OpenEMS-Build'
	description 'Checkstyle all bundles'

	subprojects.each { proj ->
		if (proj.tasks.findAll { it.name == 'checkstyleMain' }) {
			dependsOn(proj.checkstyleMain)
		}
	}
}

task cleanBackend() {
	group 'OpenEMS-Build'
	description 'Clean all Backend-Bundles'
	
	subprojects.each { proj ->
		if( proj.name ==~ /io.openems.(backend|common|shared|wrapper).*/ ) {
			if (proj.tasks.findAll { it.name == 'clean' }) {
				dependsOn(proj.clean)
			}
		}
	}
}

task assembleEdge() {
	group 'OpenEMS-Build'
	description 'Assemble all Edge-Bundles'
	
	subprojects.each { proj ->
		if( proj.name ==~ /io.openems.(common|edge|oem|shared|wrapper).*/ ) {
			if (proj.tasks.findAll { it.name == 'assemble' }) {
				dependsOn(proj.assemble)
			}
		}
	}
}

task assembleBackend() {
	group 'OpenEMS-Build'
	description 'Assemble all Backend-Bundles'
	
	subprojects.each { proj ->
		if( proj.name ==~ /io.openems.(backend|common|oem|shared|wrapper).*/ ) {
			if (proj.tasks.findAll { it.name == 'assemble' }) {
				dependsOn(proj.assemble)
			}
		}
	}
}

/*
 * Build OpenEMS Edge and Backend Components
 */
task buildComponents() {
	subprojects.each { proj ->
		if (proj.tasks.findAll { it.name == 'compileJava' }) {
			dependsOn(proj.compileJava)
			proj.test {
				testLogging {
					events "passed", "skipped", "failed", "standardOut", "standardError"
				}
			}
		}
	}
}

task buildEdge() {
	group 'OpenEMS-Build'
	description 'Build a Fat-Jar for the OpenEMS-Edge into build/openems-edge.jar'
	
	def assemble = tasks.getByPath(':assembleEdge')
	def export = tasks.getByPath(':io.openems.edge.application:export.EdgeApp')
	def resolve = tasks.getByPath(':io.openems.edge.application:resolve.EdgeApp')
	
	dependsOn assemble
	dependsOn export
	dependsOn resolve
	
	resolve.mustRunAfter assemble
	export.mustRunAfter resolve
	
	/* force rebuild */
	export.outputs.upToDateWhen { false }
	outputs.upToDateWhen { false }
	
	doLast {
		def source = file("io.openems.edge.application/generated/distributions/executable/EdgeApp.jar")
		def output = file(System.getenv('OEMS_EDGE_OUTPUT') ?: "${buildDir}/openems-edge.jar")

		output.delete()
		copy {
			from source
			into output.getParentFile()
			rename (source.getName(), output.getName())
		}
		println("Built ${output}!")
	}
}

task buildBackend() {
	group 'OpenEMS-Build'
	description 'Build a Fat-Jar for the OpenEMS-Backend into build/openems-backend.jar'
	
	def assemble = tasks.getByPath(':assembleBackend')
	def export = tasks.getByPath(':io.openems.backend.application:export.BackendApp')
	def resolve = tasks.getByPath(':io.openems.backend.application:resolve.BackendApp')
	
	dependsOn assemble
	dependsOn export
	dependsOn resolve
	
	resolve.mustRunAfter assemble
	export.mustRunAfter resolve
	
	/* force rebuild */
	export.outputs.upToDateWhen { false }
	outputs.upToDateWhen { false }

	doLast {
		def source = file("io.openems.backend.application/generated/distributions/executable/BackendApp.jar")
		def output = file(System.getenv('OEMS_BACKEND_OUTPUT') ?: "${buildDir}/openems-backend.jar")

		output.delete()
		copy {
			from source
			into output.getParentFile()
			rename (source.getName(), output.getName())
		}
		println("Built ${output}!")
	}
}

/*
 * Javadoc
 */
task buildAggregatedJavadocs(type: Javadoc, description: 'Generate javadocs from all child projects as if it was a single project', group: 'Documentation') {
	destinationDir = file("$buildDir/www/javadoc")
	title = "OpenEMS Javadoc"
	subprojects.each { proj ->
		proj.tasks.withType(Javadoc).each { javadocTask ->
			javadocTask.options.encoding = 'UTF-8'
			options.addStringOption('Xdoclint:none', '-quiet')
			source += javadocTask.source
			classpath += javadocTask.classpath
			excludes += javadocTask.excludes
			includes += javadocTask.includes
		}
	}
}

/*
 * Copies Bundle readme.adoc files to doc.
 */
task copyBundleReadmes() {
	doLast {
		// define target files
		def basePath = projectDir.getPath() + "/doc/modules/ROOT/pages/"
		def targetController = basePath + "edge/controller.adoc.d"
		def targetScheduler = basePath + "edge/scheduler.adoc.d"
		def targetNature = basePath + "edge/nature.adoc.d"
		def targetBridge = basePath + "edge/bridge.adoc.d"
		def targetDeviceService = basePath + "edge/device_service.adoc.d"
		def targetTimedata = basePath + "edge/timedata.adoc.d"
		def targetBackendService = basePath + "backend/service.adoc.d"

		// initialize target files and directories
		[targetController, targetScheduler, targetNature, targetBridge, targetDeviceService, targetTimedata, targetBackendService].each { target ->
			delete fileTree(dir: target, include: '**/*.adoc')
			new File(target + "/_include.adoc").write('')
		}

		subprojects.each { proj ->
			// in each subproject (= bundle)...
			proj.file(".").listFiles().each { sourceFile ->
				// find the 'readme.adoc' file
				if(sourceFile.getName().equalsIgnoreCase("readme.adoc")) {
					def bundle = sourceFile.getParentFile().getName()
					def target = null

					if(bundle.startsWith("io.openems.edge.")) {
						def edgeBundle = bundle.substring("io.openems.edge.".length())
						if(edgeBundle.endsWith(".api")) {
							target = targetNature
						} else if(edgeBundle.startsWith("controller.")) {
							target = targetController
						} else if(edgeBundle.startsWith("scheduler.")) {
							target = targetScheduler
						} else if(edgeBundle.startsWith("bridge.")) {
							target = targetBridge
						} else if(edgeBundle.startsWith("timedata.")) {
							target = targetTimedata
						} else {
							target = targetDeviceService
						}
	
					} else if(bundle.startsWith("io.openems.backend.")) {
						def backendBundle = bundle.substring("io.openems.backend.".length())
						if(backendBundle.startsWith("timedata.")) {
							target = targetBackendService
						} else if(backendBundle.startsWith("metadata.")) {
							target = targetBackendService
						} else {
							return // ignore
						}

					} else if(bundle.startsWith("io.openems.wrapper")
						|| bundle.startsWith("io.openems.oem.")) {
						// ignore
						return
					}
	
					// could we exactly evaluate the bundle type and set the targetFile?
					if(target == null) {
						throw new Exception("Bundle type is unknown for " + bundle)
					}
	
					// copy the readme file to "target.d" folder
					copy {
						from (sourceFile.toPath())
						into (target)
						rename { fileName ->
							return bundle + ".adoc"
						}
					}
	
					// append content of source file to target file
					File targetFile = new File(target + "/_include.adoc")
					targetFile.append("\ninclude::" + bundle + ".adoc[leveloffset=+1]\n")
				}
			}
		}
	}
}

/*
 * Build Antora docs
 */
task buildAntoraDocs(dependsOn: copyBundleReadmes) {
	group 'Documentation'
	
	dependsOn ":doc:buildAntoraDocs"
	doLast {
		copy {
			from "doc/build/www"
			into "${buildDir}/www"
		}
	}
}