FREEMARKER-218: Jakarta support

.github/workflows/ci.yml

@@ -48,6 +48,11 @@ jobs:
         with:
           java-version: 16
           distribution: zulu
+      - name: Set up JDK 17
+        uses: actions/setup-java@v3
+        with:
+          java-version: 17
+          distribution: oracle
       - name: Validate Gradle wrapper
         uses: gradle/[email protected]
       - name: Run Build
@@ -60,4 +65,3 @@ jobs:
           name: test-reports-${{ matrix.os }}
           path: build/reports/**
           retention-days: 30
-

README.md

@@ -106,7 +106,7 @@ If you haven't yet, download the source release, or checkout FreeMarker from
 the source code repository. See repository locations here:
 https://freemarker.apache.org/sourcecode.html
 
-You need JDK 8 and JDK 16 to be installed
+You need JDK 8, JDK 16 and JDK 17 (only for some tests) to be installed
 (and [visible to Gradle](https://docs.gradle.org/current/userguide/toolchains.html)).
 
 Be sure that your default Java version (which Gradle should use automatically) is at

build.gradle.kts

@@ -20,7 +20,7 @@
 import java.io.FileOutputStream
 import java.nio.charset.StandardCharsets
 import java.nio.file.Files
-import java.util.*
+import java.util.Properties
 import java.util.stream.Collectors
 
 plugins {
@@ -58,6 +58,36 @@ freemarkerRoot {
     configureSourceSet("jython22")
     configureSourceSet("jython25") { enableTests() }
     configureSourceSet("core16", "16")
+
+    configureGeneratedSourceSet("jakartaServlet") {
+        val jakartaSourceGenerators = generateJakartaSources("javaxServlet")
+
+        val testSourceSet = enableTests("17").get().sources
+        val jakartaTestSourceGenerators = generateJakartaSources(
+            "javaxServletTest",
+            SourceSet.TEST_SOURCE_SET_NAME,
+            testSourceSet
+        )
+
+        (jakartaSourceGenerators + jakartaTestSourceGenerators).forEach { task ->
+            task.configure {
+                packageMappings.set(mapOf(
+                    "freemarker.ext.jsp" to "freemarker.ext.jakarta.jsp",
+                    "freemarker.ext.servlet" to "freemarker.ext.jakarta.servlet",
+                    "freemarker.cache" to "freemarker.ext.jakarta.servlet",
+                ))
+                noAutoReplacePackages.set(setOf("freemarker.cache"))
+                replacements.set(mapOf(
+                    "package freemarker.cache" to "package freemarker.ext.jakarta.servlet",
+                    "freemarker.cache.WebappTemplateLoader" to "freemarker.ext.jakarta.servlet.WebappTemplateLoader",
+                    "javax.servlet" to "jakarta.servlet",
+                    "javax.el" to "jakarta.el",
+                    "http://java.sun.com/jsp/jstl/core" to "jakarta.tags.core",
+                    "http://java.sun.com/jsp/jstl/functions" to "jakarta.tags.functions",
+                ))
+            }
+        }
+    }
 }
 
 val compileJavacc = tasks.register<freemarker.build.CompileJavaccTask>("compileJavacc") {
@@ -127,6 +157,10 @@ configurations {
         extendsFrom(named("jython25CompileClasspath").get())
         extendsFrom(named("javaxServletCompileClasspath").get())
     }
+    register("javadocClasspath") {
+        extendsFrom(named("combinedClasspath").get())
+        extendsFrom(named("jakartaServletCompileClasspath").get())
+    }
 }
 
 // This source set is only needed, because the OSGI plugin supports only a single sourceSet.
@@ -230,7 +264,7 @@ tasks.named<Javadoc>(JavaPlugin.JAVADOC_TASK_NAME) {
         addStringOption("Xdoclint:-missing", "-quiet")
     }
 
-    classpath = files(configurations.named("combinedClasspath"))
+    classpath = files(configurations.named("javadocClasspath"))
 }
 
 fun registerManualTask(taskName: String, localeValue: String, offlineValue: Boolean) {
@@ -441,14 +475,14 @@ val createBuildInfo = tasks.register("createBuildInfo") {
         val props = Properties().apply {
             // see https://reproducible-builds.org/docs/jvm/
             setProperty("buildinfo.version", "1.0-SNAPSHOT")
-            
+
             setProperty("java.version", System.getProperty("java.version"))
             setProperty("java.vendor", System.getProperty("java.vendor"))
             setProperty("os.name", System.getProperty("os.name"))
-            
+
             setProperty("source.scm.uri", "scm:git:https://git-wip-us.apache.org/repos/asf/freemarker.git")
             setProperty("source.scm.tag", "v${fmExt.versionDef.version}")
-            
+
             setProperty("build-tool", "gradle")
             setProperty("build.setup", "https://github.com/apache/freemarker/blob/2.3-gae/README.md#building-freemarker")
 
@@ -560,9 +594,13 @@ eclipse {
 
 val jettyVersion = "9.4.53.v20231009"
 val slf4jVersion = "1.6.1"
-val springVersion = "2.5.6.SEC03"
+val springVersion = "5.3.31"
 val tagLibsVersion = "1.2.5"
 
+val jakartaJettyVersion = "11.0.19"
+val jakartaSlf4jVersion = "2.0.9"
+val jakartaSpringVersion = "6.1.2"
+
 configurations {
     compileOnly {
         exclude(group = "xml-apis", module = "xml-apis")
@@ -599,6 +637,10 @@ dependencies {
 
     testImplementation(xalan)
 
+    "jakartaServletCompileOnly"("jakarta.servlet:jakarta.servlet-api:5.0.0")
+    "jakartaServletCompileOnly"("jakarta.servlet.jsp:jakarta.servlet.jsp-api:3.0.0")
+    "jakartaServletCompileOnly"("jakarta.el:jakarta.el-api:4.0.0")
+
     "javaxServletCompileOnly"("javax.servlet:javax.servlet-api:3.0.1")
     "javaxServletCompileOnly"("javax.servlet.jsp:jsp-api:2.2")
     "javaxServletCompileOnly"("javax.el:el-api:2.2")
@@ -619,6 +661,39 @@ dependencies {
     "javaxServletTestImplementation"("org.springframework:spring-test:${springVersion}") {
         exclude(group = "commons-logging", module = "commons-logging")
     }
+    "javaxServletTestImplementation"("org.springframework:spring-web:${springVersion}") {
+        exclude(group = "commons-logging", module = "commons-logging")
+    }
+    "javaxServletTestImplementation"("com.github.hazendaz:displaytag:2.5.3")
+
+    "jakartaServletTestImplementation"("org.eclipse.jetty:jetty-server:${jakartaJettyVersion}")
+    "jakartaServletTestImplementation"("org.eclipse.jetty:jetty-annotations:${jakartaJettyVersion}")
+    "jakartaServletTestImplementation"("org.eclipse.jetty:jetty-webapp:${jakartaJettyVersion}")
+    "jakartaServletTestImplementation"("org.eclipse.jetty:jetty-util:${jakartaJettyVersion}")
+    "jakartaServletTestImplementation"("org.eclipse.jetty:apache-jsp:${jakartaJettyVersion}")
+    // Jetty also contains the servlet-api and jsp-api and el-api classes
+
+    "jakartaServletTestImplementation"("jakarta.servlet:jakarta.servlet-api:6.0.0")
+    "jakartaServletTestImplementation"("jakarta.servlet.jsp:jakarta.servlet.jsp-api:3.0.0")
+    "jakartaServletTestImplementation"("jakarta.el:jakarta.el-api:4.0.0")
+
+    // JSP JSTL (not included in Jetty):
+    "jakartaServletTestImplementation"("com.github.hazendaz:displaytag:3.0.0-M2")
+
+    "jakartaServletTestImplementation"("org.springframework:spring-core:${jakartaSpringVersion}") {
+        exclude(group = "commons-logging", module = "commons-logging")
+    }
+    "jakartaServletTestImplementation"("org.springframework:spring-test:${jakartaSpringVersion}") {
+        exclude(group = "commons-logging", module = "commons-logging")
+    }
+    "jakartaServletTestImplementation"("org.springframework:spring-web:${jakartaSpringVersion}") {
+        exclude(group = "commons-logging", module = "commons-logging")
+    }
+
+    "jakartaServletTestRuntimeOnly"("org.slf4j:slf4j-api:${jakartaSlf4jVersion}")
+    "jakartaServletTestRuntimeOnly"("org.slf4j:log4j-over-slf4j:${jakartaSlf4jVersion}")
+    "jakartaServletTestRuntimeOnly"("org.slf4j:jcl-over-slf4j:${jakartaSlf4jVersion}")
+    "jakartaServletTestRuntimeOnly"("ch.qos.logback:logback-classic:1.3.14")
 
     "jython20CompileOnly"("jython:jython:2.1")
 
@@ -628,13 +703,6 @@ dependencies {
     "jython25CompileOnly"(sourceSets["jython20"].output)
     "jython25CompileOnly"("org.python:jython:2.5.0")
 
-    "testUtilsImplementation"("com.github.hazendaz:displaytag:2.5.3") {
-        exclude(group = "com.lowagie", module = "itext")
-        // We manage logging centrally:
-        exclude(group = "org.slf4j", module = "slf4j-log4j12")
-        exclude(group = "rg.slf4j", module = "jcl104-over-slf4j")
-        exclude(group = "log4j", module = "log4j")
-    }
     "testUtilsImplementation"(sourceSets.main.get().output)
     "testUtilsImplementation"("com.google.code.findbugs:annotations:3.0.0")
     "testUtilsImplementation"(libs.junit)
@@ -643,7 +711,5 @@ dependencies {
     "testUtilsImplementation"("commons-io:commons-io:2.7")
     "testUtilsImplementation"("com.google.guava:guava:29.0-jre")
     "testUtilsImplementation"("commons-collections:commons-collections:3.1")
-
-    // Override Java 9 incompatible version (coming from displaytag):
     "testUtilsImplementation"("commons-lang:commons-lang:2.6")
 }

buildSrc/src/main/kotlin/freemarker/build/FreemarkerRootExtension.kt

@@ -19,6 +19,7 @@
 
 package freemarker.build
 
+import java.util.concurrent.atomic.AtomicBoolean
 import org.gradle.api.NamedDomainObjectProvider
 import org.gradle.api.Project
 import org.gradle.api.artifacts.VersionCatalogsExtension
@@ -29,19 +30,20 @@ import org.gradle.api.plugins.jvm.JvmTestSuite
 import org.gradle.api.plugins.jvm.JvmTestSuiteTarget
 import org.gradle.api.provider.Provider
 import org.gradle.api.tasks.SourceSet
+import org.gradle.api.tasks.TaskProvider
 import org.gradle.api.tasks.bundling.Jar
 import org.gradle.api.tasks.compile.JavaCompile
 import org.gradle.api.tasks.javadoc.Javadoc
 import org.gradle.jvm.toolchain.JavaLanguageVersion
 import org.gradle.jvm.toolchain.JavaToolchainService
 import org.gradle.kotlin.dsl.dependencies
 import org.gradle.kotlin.dsl.named
+import org.gradle.kotlin.dsl.register
 import org.gradle.kotlin.dsl.setProperty
 import org.gradle.kotlin.dsl.the
 import org.gradle.language.base.plugins.LifecycleBasePlugin
 import org.gradle.language.jvm.tasks.ProcessResources
 import org.gradle.testing.base.TestingExtension
-import java.util.concurrent.atomic.AtomicBoolean
 
 private const val TEST_UTILS_SOURCE_SET_NAME = "test-utils"
 
@@ -90,6 +92,7 @@ internal class JavaProjectContext constructor(
 class FreemarkerModuleDef internal constructor(
     private val context: JavaProjectContext,
     private val ext: FreemarkerRootExtension,
+    private val generated: Boolean,
     val sourceSetName: String,
     val compilerVersion: JavaLanguageVersion
 ) {
@@ -99,27 +102,71 @@ class FreemarkerModuleDef internal constructor(
     val sourceSet = context.sourceSets.maybeCreate(sourceSetName)
 
     val sourceSetRootDirName = "freemarker-${baseDirName}"
-    val sourceSetSrcPath = "${sourceSetRootDirName}/src"
+    val sourceSetSrcPath = sourceSetRoot(context, generated, sourceSetRootDirName)
+
+    fun generateJakartaSources(
+        baseSourceSetName: String,
+        sourceSetKind: String = SourceSet.MAIN_SOURCE_SET_NAME,
+        targetSourceSet: SourceSet = sourceSet
+    ): List<TaskProvider<JakartaSourceRootGeneratorTask>> {
+        val baseSourceSetRef = context.sourceSets.named(baseSourceSetName)
+        val taskNameClassifier = if (SourceSet.MAIN_SOURCE_SET_NAME == sourceSetKind) {
+            ""
+        } else {
+            sourceSetKind.replaceFirstChar { it.uppercaseChar() }
+        }
 
-    fun enableTests(testJavaVersion: String = ext.testJavaVersion) {
-        configureTests(JavaLanguageVersion.of(testJavaVersion))
+        val generateJakartaSources = context.tasks
+            .register<JakartaSourceRootGeneratorTask>("generateJakarta${taskNameClassifier}Sources") {
+                sourceDirectory.set(baseSourceSetRef.get().java.srcDirs.single())
+                destinationDirectory.set(project.file(sourceSetSrcPath).resolve(sourceSetKind).resolve("java"))
+            }
+        targetSourceSet.java.srcDir(generateJakartaSources)
+
+        val generateJakartaResources = context.tasks
+            .register<JakartaSourceRootGeneratorTask>("generateJakarta${taskNameClassifier}Resources") {
+                sourceDirectory.set(baseSourceSetRef.get().resources.srcDirs.single())
+                destinationDirectory.set(project.file(sourceSetSrcPath).resolve(sourceSetKind).resolve("resources"))
+            }
+        targetSourceSet.resources.srcDir(generateJakartaResources)
+        return listOf(generateJakartaSources, generateJakartaResources)
     }
 
-    private fun configureTests(testJavaVersion: JavaLanguageVersion) {
-        getOrCreateTestSuiteRef().configure {
+    private fun sourceSetRoot(
+        context: JavaProjectContext,
+        generated: Boolean,
+        sourceSetRootDirName: String
+    ): String {
+        return if (generated) {
+            context.project.layout.buildDirectory.get().asFile
+                .resolve("generated")
+                .resolve(sourceSetRootDirName)
+                .toString()
+        } else {
+            "${sourceSetRootDirName}/src"
+        }
+    }
+
+    fun enableTests(testJavaVersion: String = ext.testJavaVersion) =
+        configureTests(JavaLanguageVersion.of(testJavaVersion))
+
+    private fun configureTests(testJavaVersion: JavaLanguageVersion): NamedDomainObjectProvider<JvmTestSuite> {
+        val testSuitRef = getOrCreateTestSuiteRef()
+        testSuitRef.configure {
             useJUnit(context.version("junit"))
 
             configureSources(sources, testJavaVersion)
             targets.all { configureTarget(this, sources, testJavaVersion) }
         }
+        return testSuitRef
     }
 
     private fun getOrCreateTestSuiteRef(): NamedDomainObjectProvider<JvmTestSuite> {
         val suites = context.testing.suites
-        if (main) {
-            return suites.named<JvmTestSuite>(JvmTestSuitePlugin.DEFAULT_TEST_SUITE_NAME)
+        return if (main) {
+            suites.named<JvmTestSuite>(JvmTestSuitePlugin.DEFAULT_TEST_SUITE_NAME)
         } else {
-            return suites.register("${sourceSetName}Test", JvmTestSuite::class.java)
+            suites.register("${sourceSetName}Test", JvmTestSuite::class.java)
         }
     }
 
@@ -134,9 +181,14 @@ class FreemarkerModuleDef internal constructor(
 
     private fun configureSources(sources: SourceSet, testJavaVersion: JavaLanguageVersion) {
         sources.apply {
-            val testSrcPath = "${sourceSetSrcPath}/test"
-            java.setSrcDirs(listOf("${testSrcPath}/java"))
-            resources.setSrcDirs(listOf("${testSrcPath}/resources"))
+            if (generated) {
+                java.setSrcDirs(emptyList<String>())
+                resources.setSrcDirs(emptyList<String>())
+            } else {
+                val testSrcPath = "${sourceSetSrcPath}/test"
+                java.setSrcDirs(listOf("${testSrcPath}/java"))
+                resources.setSrcDirs(listOf("${testSrcPath}/resources"))
+            }
 
             if (!main) {
                 context.inheritCompileRuntimeAndOutput(this, sourceSet)
@@ -238,6 +290,21 @@ class FreemarkerRootExtension constructor(
         }
     }
 
+    fun configureGeneratedSourceSet(
+        sourceSetName: String,
+        configuration: FreemarkerModuleDef.() -> Unit = { }
+    ) {
+        configureGeneratedSourceSet(sourceSetName, javaVersion, configuration)
+    }
+
+    fun configureGeneratedSourceSet(
+        sourceSetName: String,
+        sourceSetVersion: String,
+        configuration: FreemarkerModuleDef.() -> Unit = { }
+    ) {
+        configureSourceSet(true, sourceSetName, sourceSetVersion, configuration)
+    }
+
     fun configureSourceSet(
         sourceSetName: String,
         configuration: FreemarkerModuleDef.() -> Unit = { }
@@ -249,19 +316,32 @@ class FreemarkerRootExtension constructor(
         sourceSetName: String,
         sourceSetVersion: String,
         configuration: FreemarkerModuleDef.() -> Unit = { }
+    ) {
+        configureSourceSet(false, sourceSetName, sourceSetVersion, configuration)
+    }
+
+    private fun configureSourceSet(
+        generated: Boolean,
+        sourceSetName: String,
+        sourceSetVersion: String,
+        configuration: FreemarkerModuleDef.() -> Unit = { }
     ) {
         if (testUtilsConfigured.compareAndSet(false, true)) {
             configureTestUtils()
         }
 
         allConfiguredSourceSetNamesRef.add(sourceSetName)
 
-        FreemarkerModuleDef(context, this, sourceSetName, JavaLanguageVersion.of(sourceSetVersion)).apply {
-            val sourceSetSrcMainPath = "${sourceSetSrcPath}/main"
-
+        FreemarkerModuleDef(context, this, generated, sourceSetName, JavaLanguageVersion.of(sourceSetVersion)).apply {
             sourceSet.apply {
-                java.setSrcDirs(listOf("${sourceSetSrcMainPath}/java"))
-                resources.setSrcDirs(listOf("${sourceSetSrcMainPath}/resources"))
+                if (generated) {
+                    java.setSrcDirs(emptyList<String>())
+                    resources.setSrcDirs(emptyList<String>())
+                } else {
+                    val sourceSetSrcMainPath = "${sourceSetSrcPath}/main"
+                    java.setSrcDirs(listOf("${sourceSetSrcMainPath}/java"))
+                    resources.setSrcDirs(listOf("${sourceSetSrcMainPath}/resources"))
+                }
             }
 
             if (!main) {