build.gradle

/*
 * Copyright 2002-2018 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 */

plugins {
    id 'io.spring.dependency-management' version "1.1.4"
}

def coreProjects = subprojects.findAll { !it.name.contains("sample") }

configure(allprojects) { project ->
	group = "de.governikus.spring.security.extensions"

	ext.slf4jVersion = "2.0.7"
	ext.springVersion = "6.0.10"
	ext.springSecurityVersion = "6.1.1"
	ext.bcprovVersion = "1.78.1"
	ext.bcpkixVersion = "1.78.1"
	ext.openSamlVersion = "4.3.0"
	ext.gradleScriptDir = "${rootProject.projectDir}/gradle"
	ext.junitVersion = "5.9.3"
    ext.jaxbApiVersion = "4.0.2"
    ext.mockitoVersion = "5.0.0"
    ext.byteBuddyVersion = "1.12.8"
    ext.httpClient = "5.2.1"

	apply plugin: "java"
	apply from: "${gradleScriptDir}/ide.gradle"

	compileJava {
		sourceCompatibility=17
		targetCompatibility=17
	}
	compileTestJava {
		sourceCompatibility=17
		targetCompatibility=17
	}

	test {
		useJUnitPlatform()
		systemProperty("java.awt.headless", "true")
		maxParallelForks = project.maxParallelForks as int
	}

	repositories {
		mavenCentral()
		maven { url "https://build.shibboleth.net/nexus/content/repositories/releases" }
	}

	dependencies {
        testImplementation (group: "org.junit.jupiter", name: "junit-jupiter-api", version: "$junitVersion")
        testImplementation (group: "org.junit.jupiter", name: "junit-jupiter-engine", version: "$junitVersion")
        testImplementation (group: "org.junit.jupiter", name: "junit-jupiter-params", version: "$junitVersion")
        testImplementation (group: "org.junit.platform", name: "junit-platform-launcher", version: "1.8.2")
	}


	ext.javadocLinks = [
	] as String[]
}

configure(subprojects) { subproject ->
	apply from: "${gradleScriptDir}/publish-maven.gradle"
}

configure(coreProjects) { p ->
    configurations {
        testImplementation.extendsFrom compileOnly
    }

    jar {
        manifest {
            attributes(
                    "Created-By": "${System.getProperty("java.version")} (${System.getProperty("java.specification.vendor")})",
                    "Implementation-Title": p.name,
                    "Implementation-Version": p.version
            )
        }

        from("${rootProject.projectDir}/docs/dist") {
            include "license.txt"
            into "META-INF"
            expand(
                    copyright: new Date().format("yyyy"),
                    version: project.version
            )
        }
    }

    javadoc {
        failOnError = false
        description = "Generates project-level javadoc for use in -javadoc jar"
        options {
            memberLevel = JavadocMemberLevel.PROTECTED
            author = true
            header = project.name
        }

        logging.captureStandardError LogLevel.INFO
        logging.captureStandardOutput LogLevel.INFO
    }

    tasks.register('sourcesJar', Jar) {
        dependsOn classes
        archiveClassifier = "sources"
        from sourceSets.main.allJava.srcDirs
        include "**/*.java", "**/*.aj"
    }

    tasks.register('javadocJar', Jar) {
        archiveClassifier = "javadoc"
        from javadoc
    }

    artifacts {
        archives sourcesJar
        archives javadocJar
    }
}

configure(rootProject) {
	description = "Spring Security SAML"

	// don't publish the default jar for the root project
	configurations.archives.artifacts.clear()

	task api(type: Javadoc) {
		failOnError = false
		group = "Documentation"
		description = "Generates aggregated Javadoc API documentation."
		title = "${rootProject.description} ${version} API"

		dependsOn {
			coreProjects.collect {
				it.tasks.getByName("jar")
			}
		}
		options.memberLevel = org.gradle.external.javadoc.JavadocMemberLevel.PROTECTED
		options.author = true
		options.header = rootProject.description
		options.splitIndex = true
		options.links(project.ext.javadocLinks)

		source coreProjects.collect { project ->
			project.sourceSets.main.allJava
		}

		destinationDir = new File(buildDir, "api")

		doFirst {
			classpath += files(coreProjects.collect { it.sourceSets.main.compileClasspath })
		}
	}

	task docsZip(type: Zip) {
		group = "Distribution"
        archiveBaseName = "spring-security-saml"
        archiveClassifier = "docs"
		description = "Builds -${archiveClassifier} archive containing api and reference " +
			"for deployment at https://docs.spring.io/spring-security-saml/docs."

		from (api) {
			into "api"
		}

	}

	task distZip(type: Zip, dependsOn: [docsZip]) {
		group = "Distribution"
        archiveBaseName = "spring-security-saml"
        archiveClassifier = "dist"
		description = "Builds -${archiveClassifier} archive, containing all jars and docs, " +
					"suitable for community download page."

		ext.baseDir = "${archiveBaseName}-${project.version}"

		from("docs/dist") {
			include "readme.txt"
			include "license.txt"
			include "notice.txt"
			into "${baseDir}"
			expand(copyright: new Date().format("yyyy"), version: project.version)
		}

		from(zipTree(docsZip.archivePath)) {
			into "${baseDir}/docs"
		}

        from("sample") {
            include "src/**/*"
            include "pom.xml"
            into "${baseDir}/sample"
        }

		coreProjects.each { subproject ->
			into ("${baseDir}/libs") {
				from subproject.jar
				if (subproject.tasks.findByPath("sourcesJar")) {
					from subproject.sourcesJar
				}
				if (subproject.tasks.findByPath("javadocJar")) {
					from subproject.javadocJar
				}
			}
		}
	}

	// Create an distribution that contains all dependencies (required and optional).
	// Not published by default; only for use when building from source.
	task depsZip(type: Zip, dependsOn: distZip) { zipTask ->
		group = "Distribution"
        archiveBaseName = "spring-security-saml"
        archiveClassifier = "dist-with-deps"
		description = "Builds -${archiveClassifier } archive, containing everything " +
			"in the -${distZip.archiveClassifier } archive plus all runtime dependencies."

		from zipTree(distZip.archiveFile)

		gradle.taskGraph.whenReady { taskGraph ->
			if (taskGraph.hasTask(":${zipTask.name}")) {
				def projectNames = rootProject.subprojects*.name
				def artifacts = new HashSet()
				coreProjects.each { subproject ->
					(subproject.configurations.runtime.resolvedConfiguration.resolvedArtifacts +
					subproject.configurations.optional.resolvedConfiguration.resolvedArtifacts).each { artifact ->
						def dependency = artifact.moduleVersion.id
						if (!projectNames.contains(dependency.name)) {
							artifacts << artifact.file
						}
					}
				}

				zipTask.from(artifacts) {
					into "${distZip.baseDir}/deps"
				}
			}
		}
	}

	artifacts {
		archives docsZip
		archives distZip
	}
}