description = "Spring Framework Docs"

apply plugin: 'kotlin'

apply plugin: 'org.asciidoctor.jvm.convert'

apply plugin: 'org.asciidoctor.jvm.pdf'

apply from: "${rootDir}/gradle/publications.gradle"

configurations {

asciidoctorExtensions

}

dependencies {

api(project(":spring-context"))

api(project(":spring-web"))

api("jakarta.servlet:jakarta.servlet-api")

implementation(project(":spring-core-test"))

implementation("org.assertj:assertj-core")

}

jar {

enabled = false

}

javadoc {

enabled = false

}

dependencies {

asciidoctorExtensions "io.spring.asciidoctor.backends:spring-asciidoctor-backends:0.0.5"

}

task api(type: Javadoc) {

group = "Documentation"

description = "Generates aggregated Javadoc API documentation."

title = "${rootProject.description} ${version} API"

dependsOn {

moduleProjects.collect {

it.tasks.getByName("jar")

}

}

doFirst {

classpath = files(

// ensure the javadoc process can resolve types compiled from .aj sources

project(":spring-aspects").sourceSets.main.output

)

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

}

options {

encoding = "UTF-8"

memberLevel = JavadocMemberLevel.PROTECTED

author = true

header = rootProject.description

use = true

overview = "framework-docs/src/docs/api/overview.html"

splitIndex = true

links(project.ext.javadocLinks)

addBooleanOption('Xdoclint:syntax', true) // only check syntax with doclint

addBooleanOption('Werror', true) // fail build on Javadoc warnings

}

source moduleProjects.collect { project ->

project.sourceSets.main.allJava

}

maxMemory = "1024m"

destinationDir = file("$buildDir/docs/javadoc")

}

rootProject.tasks.dokkaHtmlMultiModule.configure {

dependsOn {

tasks.getByName("api")

}

moduleName.set("spring-framework")

outputDirectory.set(project.file("$buildDir/docs/kdoc"))

}

asciidoctorj {

version = '2.4.3'

fatalWarnings ".*"

options doctype: 'book', eruby: 'erubis'

attributes([

icons: 'font',

idprefix: '',

idseparator: '-',

revnumber: project.version,

sectanchors: '',

sectnums: '',

'spring-version': project.version

])

}

asciidoctor {

baseDirFollowsSourceDir()

configurations "asciidoctorExtensions"

sources {

include '*.adoc'

}

resources {

from(sourceDir) {

include 'images/*.png'

}

}

outputDir "$buildDir/docs/ref-docs/html5"

outputOptions {

backends "spring-html"

}

forkOptions {

jvmArgs += ["--add-opens", "java.base/sun.nio.ch=ALL-UNNAMED", "--add-opens", "java.base/java.io=ALL-UNNAMED"]

}

logDocuments = true

}

asciidoctor.mustRunAfter "check"

asciidoctorPdf {

baseDirFollowsSourceDir()

configurations 'asciidoctorExtensions'

sources {

include 'spring-framework.adocbook'

}

outputDir "$buildDir/docs/ref-docs/pdf"

forkOptions {

jvmArgs += ["--add-opens", "java.base/sun.nio.ch=ALL-UNNAMED", "--add-opens", "java.base/java.io=ALL-UNNAMED"]

}

logDocuments = true

}

task docsZip(type: Zip, dependsOn: ['api', 'asciidoctor', 'asciidoctorPdf', rootProject.tasks.dokkaHtmlMultiModule]) {

group = "Distribution"

description = "Builds -${archiveClassifier} archive containing api and reference " +

"for deployment at https://docs.spring.io/spring-framework/docs/."

archiveBaseName.set("spring-framework")

archiveClassifier.set("docs")

from("src/dist") {

include "changelog.txt"

}

from (api) {

into "javadoc-api"

}

from ("$asciidoctor.outputDir") {

into "reference/html"

}

from ("$asciidoctorPdf.outputDir") {

into "reference/pdf"

}

from (rootProject.tasks.dokkaHtmlMultiModule.outputDirectory) {

into "kdoc-api"

}

}

task schemaZip(type: Zip) {

group = "Distribution"

archiveBaseName.set("spring-framework")

archiveClassifier.set("schema")

description = "Builds -${archiveClassifier} archive containing all " +

"XSDs for deployment at https://springframework.org/schema."

duplicatesStrategy DuplicatesStrategy.EXCLUDE

moduleProjects.each { module ->

def Properties schemas = new Properties();

module.sourceSets.main.resources.find {

(it.path.endsWith("META-INF/spring.schemas") || it.path.endsWith("META-INF\\spring.schemas"))

}?.withInputStream { schemas.load(it) }

for (def key : schemas.keySet()) {

def shortName = key.replaceAll(/http.*schema.(.*).spring-.*/, '$1')

assert shortName != key

File xsdFile = module.sourceSets.main.resources.find {

(it.path.endsWith(schemas.get(key)) || it.path.endsWith(schemas.get(key).replaceAll('\\/','\\\\')))

}

assert xsdFile != null

into (shortName) {

from xsdFile.path

}

}

}

}

task distZip(type: Zip, dependsOn: [docsZip, schemaZip]) {

group = "Distribution"

archiveBaseName.set("spring-framework")

archiveClassifier.set("dist")

description = "Builds -${archiveClassifier} archive, containing all jars and docs, " +

"suitable for community download page."

ext.baseDir = "spring-framework-${project.version}";

from("src/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.archiveFile)) {

into "${baseDir}/docs"

}

from(zipTree(schemaZip.archiveFile)) {

into "${baseDir}/schema"

}

moduleProjects.each { module ->

into ("${baseDir}/libs") {

from module.jar

if (module.tasks.findByPath("sourcesJar")) {

from module.sourcesJar

}

if (module.tasks.findByPath("javadocJar")) {

from module.javadocJar

}

}

}

}

distZip.mustRunAfter moduleProjects.check

publishing {

publications {

mavenJava(MavenPublication) {

artifact docsZip

artifact schemaZip

artifact distZip

}

}

}