| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you 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 |
| * |
| * http://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. |
| */ |
| |
| import java.nio.charset.StandardCharsets |
| import java.nio.file.FileVisitResult |
| import java.nio.file.Files |
| import java.nio.file.SimpleFileVisitor |
| import java.nio.file.attribute.BasicFileAttributes |
| import java.time.Instant |
| import java.time.ZoneOffset |
| import java.time.format.DateTimeFormatter |
| import java.util.Properties |
| import java.util.TreeSet |
| import java.util.stream.Collectors |
| |
| buildscript { |
| dependencies { |
| classpath("org.apache.freemarker.docgen:freemarker-docgen-core:0.0.2-SNAPSHOT") |
| } |
| } |
| |
| plugins { |
| `java-library` |
| `maven-publish` |
| signing |
| id("biz.aQute.bnd.builder") version "6.1.0" |
| id("org.nosphere.apache.rat") version "0.7.0" |
| } |
| |
| group = "org.freemarker" |
| |
| val buildTimeStamp = Instant.now() |
| val buildTimeStampUtc = buildTimeStamp.atOffset(ZoneOffset.UTC) |
| val versionFileTokens = mapOf( |
| "timestampNice" to buildTimeStampUtc.format(DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss'Z'")), |
| "timestampInVersion" to buildTimeStampUtc.format(DateTimeFormatter.ofPattern("yyyyMMdd'T'HHmmss'Z'")) |
| ) |
| val resourceTemplatesDir = file("freemarker-core/src/main/resource-templates") |
| val versionPropertiesTemplate = Properties() |
| Files.newBufferedReader(resourceTemplatesDir.toPath().resolve("freemarker").resolve("version.properties"), StandardCharsets.ISO_8859_1).use { |
| versionPropertiesTemplate.load(it) |
| } |
| val versionProperties = HashMap<String, String>() |
| versionPropertiesTemplate.forEach { (key, value) -> |
| var updatedValue = value.toString() |
| for (token in versionFileTokens) { |
| updatedValue = updatedValue.replace("@${token.key}@", token.value) |
| } |
| versionProperties[key.toString()] = updatedValue.trim() |
| } |
| version = versionProperties["mavenVersion"]!! |
| val displayVersion = versionProperties["version"]!! |
| |
| val freemarkerCompilerVersionOverrideRef = providers.gradleProperty("freemarkerCompilerVersionOverride") |
| val defaultJavaVersion = freemarkerCompilerVersionOverrideRef |
| .orElse(providers.gradleProperty("freemarkerDefaultJavaVersion")) |
| .getOrElse("8") |
| val testJavaVersion = providers.gradleProperty("freeMarkerTestJavaVersion") |
| .getOrElse("16") |
| val testRunnerJavaVersion = providers.gradleProperty("freeMarkerTestRunnerJavaVersion") |
| .getOrElse(testJavaVersion) |
| val javadocJavaVersion = providers.gradleProperty("freeMarkerJavadocJavaVersion") |
| .getOrElse(defaultJavaVersion) |
| val doSignPackages = providers.gradleProperty("signPublication").map { it.toBoolean() }.orElse(true) |
| |
| java { |
| withSourcesJar() |
| withJavadocJar() |
| |
| toolchain { |
| languageVersion.set(JavaLanguageVersion.of(defaultJavaVersion)) |
| } |
| } |
| |
| tasks.withType<JavaCompile>().configureEach { |
| options.encoding = "UTF-8" |
| } |
| |
| data class JavaccReplacePattern(val relPath: String, val pattern: String, val replacement: String) : java.io.Serializable |
| |
| open class CompileJavacc @Inject constructor( |
| private val fs: FileSystemOperations, |
| private val exec: ExecOperations, |
| layout: ProjectLayout, |
| objects: ObjectFactory |
| ) : DefaultTask() { |
| |
| @InputDirectory |
| val sourceDirectory: DirectoryProperty |
| |
| @OutputDirectory |
| val destinationDirectory: DirectoryProperty |
| |
| @InputFiles |
| var classpath: FileCollection |
| |
| @Input |
| val fileNameOverrides: SetProperty<String> |
| |
| @Input |
| val replacePatterns: SetProperty<JavaccReplacePattern> |
| |
| init { |
| this.sourceDirectory = objects.directoryProperty().value(layout.projectDirectory.dir("src/main/javacc")) |
| this.destinationDirectory = objects.directoryProperty().value(layout.buildDirectory.dir("generated/javacc-tmp")) |
| this.classpath = objects.fileCollection() |
| this.fileNameOverrides = objects.setProperty() |
| this.replacePatterns = objects.setProperty() |
| } |
| |
| @TaskAction |
| fun compileFiles() { |
| fs.delete { delete(destinationDirectory) } |
| |
| val destRoot = destinationDirectory.get().asFile |
| val javaccClasspath = classpath |
| |
| sourceDirectory.asFileTree.visit(object : EmptyFileVisitor() { |
| override fun visitFile(fileDetails: FileVisitDetails) { |
| val outputDir = fileDetails.relativePath.parent.getFile(destRoot) |
| Files.createDirectories(outputDir.toPath()) |
| |
| val execResult = exec.javaexec { |
| classpath = javaccClasspath |
| mainClass.set("org.javacc.parser.Main") |
| args = listOf( |
| "-OUTPUT_DIRECTORY=$outputDir", |
| fileDetails.file.toString() |
| ) |
| isIgnoreExitValue = true |
| } |
| |
| val exitCode = execResult.exitValue |
| if (exitCode != 0) { |
| throw IllegalStateException("Javacc failed with error code: $exitCode") |
| } |
| } |
| }) |
| |
| val fileNameOverridesSnapshot = fileNameOverrides.get() |
| val deletedFileNames = HashSet<String>() |
| |
| Files.walkFileTree(destRoot.toPath(), object : SimpleFileVisitor<java.nio.file.Path>() { |
| override fun visitFile(file: java.nio.file.Path, attrs: BasicFileAttributes): FileVisitResult { |
| val fileName = file.fileName.toString() |
| if (fileNameOverridesSnapshot.contains(fileName)) { |
| deletedFileNames.add(fileName) |
| Files.delete(file) |
| } |
| return FileVisitResult.CONTINUE |
| } |
| }) |
| |
| val unusedFileNames = TreeSet(fileNameOverridesSnapshot) |
| unusedFileNames.removeAll(deletedFileNames) |
| if (unusedFileNames.isNotEmpty()) { |
| logger.warn("Javacc did not generate the following files, even though they are marked as overriden: ${unusedFileNames}") |
| } |
| |
| replacePatterns.get().groupBy { it.relPath }.forEach { (relPath, patternDefs) -> |
| val file = destRoot.toPath().resolve(relPath.replace("/", File.separator)) |
| |
| val encoding = StandardCharsets.ISO_8859_1 |
| val origContent = String(Files.readAllBytes(file), encoding) |
| var adjContent = origContent |
| for (patternDef in patternDefs) { |
| val prevContent = adjContent |
| adjContent = adjContent.replace(patternDef.pattern, patternDef.replacement) |
| if (prevContent == adjContent) { |
| logger.warn("$file was not modified, because it does not contain the requested token: '${patternDef.pattern}'") |
| } |
| } |
| |
| if (origContent != adjContent) { |
| Files.write(file, adjContent.toByteArray(encoding)) |
| } |
| } |
| } |
| } |
| |
| val compileJavacc = tasks.register<CompileJavacc>("compileJavacc") { |
| sourceDirectory.set(file("freemarker-core/src/main/javacc")) |
| destinationDirectory.set(buildDir.toPath().resolve("generated").resolve("javacc").toFile()) |
| classpath = configurations.detachedConfiguration(dependencies.create("net.java.dev.javacc:javacc:7.0.12")) |
| fileNameOverrides.addAll( |
| "ParseException.java", |
| "TokenMgrError.java" |
| ) |
| |
| val basePath = "freemarker/core" |
| replacePatterns.addAll( |
| JavaccReplacePattern( |
| "${basePath}/FMParser.java", |
| "enum", |
| "ENUM" |
| ), |
| JavaccReplacePattern( |
| "${basePath}/FMParserConstants.java", |
| "public interface FMParserConstants", |
| "interface FMParserConstants" |
| ), |
| JavaccReplacePattern( |
| "${basePath}/Token.java", |
| "public class Token", |
| "class Token" |
| ), |
| // FIXME: This does nothing at the moment. |
| JavaccReplacePattern( |
| "${basePath}/SimpleCharStream.java", |
| "public final class SimpleCharStream", |
| "final class SimpleCharStream" |
| ) |
| ) |
| } |
| |
| fun <T> concatLists(vararg lists: List<T>): List<T> { |
| val concatenated = ArrayList<T>() |
| for (list in lists) { |
| concatenated.addAll(list) |
| } |
| return concatenated |
| } |
| |
| val allSourceSetNames = ArrayList<String>() |
| |
| fun configureSourceSet(sourceSetName: String, defaultCompilerVersionStr: String) { |
| allSourceSetNames.add(sourceSetName) |
| |
| val compilerVersion = freemarkerCompilerVersionOverrideRef |
| .orElse(providers.gradleProperty("java${defaultCompilerVersionStr}CompilerOverride")) |
| .getOrElse(defaultCompilerVersionStr) |
| .let { JavaLanguageVersion.of(it) } |
| |
| val baseDirName = if (sourceSetName == SourceSet.MAIN_SOURCE_SET_NAME) "core" else sourceSetName |
| |
| val sourceSet = sourceSets.maybeCreate(sourceSetName) |
| sourceSet.java.setSrcDirs(listOf("freemarker-${baseDirName}/src/main/java")) |
| sourceSet.resources.setSrcDirs(listOf("freemarker-${baseDirName}/src/main/resources")) |
| |
| val mainSourceSet = sourceSets.named(SourceSet.MAIN_SOURCE_SET_NAME).get() |
| |
| if (sourceSetName == SourceSet.MAIN_SOURCE_SET_NAME) { |
| sourceSet.java.srcDir(compileJavacc) |
| } else { |
| tasks.named<Jar>(mainSourceSet.sourcesJarTaskName) { |
| from(sourceSet.allSource) |
| } |
| |
| val compileOnlyConfigName = "${sourceSetName}${JavaPlugin.COMPILE_ONLY_CONFIGURATION_NAME.capitalize()}" |
| |
| configurations.getByName(compileOnlyConfigName) { |
| extendsFrom(configurations.named(JavaPlugin.COMPILE_ONLY_CONFIGURATION_NAME).get()) |
| } |
| |
| tasks.named<Jar>(JavaPlugin.JAR_TASK_NAME) { |
| from(sourceSet.output) |
| } |
| |
| tasks.named<Javadoc>(JavaPlugin.JAVADOC_TASK_NAME) { |
| source(sourceSet.java) |
| } |
| |
| dependencies { |
| add(compileOnlyConfigName, mainSourceSet.output) |
| testImplementation(sourceSet.output) |
| } |
| } |
| |
| if (compilerVersion != java.toolchain.languageVersion.get()) { |
| tasks.named<JavaCompile>(sourceSet.compileJavaTaskName) { |
| javaCompiler.set(javaToolchains.compilerFor { |
| languageVersion.set(compilerVersion) |
| }) |
| } |
| } |
| } |
| |
| configureSourceSet(SourceSet.MAIN_SOURCE_SET_NAME, "8") |
| configureSourceSet("jsp20", "8") |
| configureSourceSet("jsp21", "8") |
| configureSourceSet("jython20", "8") |
| configureSourceSet("jython22", "8") |
| configureSourceSet("jython25", "8") |
| configureSourceSet("core16", "16") |
| |
| sourceSets { |
| test { |
| val baseDir = "freemarker-test/src/test" |
| java.setSrcDirs(listOf("${baseDir}/java")) |
| resources.setSrcDirs(listOf("${baseDir}/resources")) |
| } |
| } |
| |
| tasks.named<JavaCompile>(sourceSets["test"].compileJavaTaskName) { |
| javaCompiler.set(javaToolchains.compilerFor { |
| languageVersion.set(JavaLanguageVersion.of(testJavaVersion)) |
| }) |
| } |
| |
| tasks.named<Javadoc>(JavaPlugin.JAVADOC_TASK_NAME) { |
| val coreExcludes = setOf( |
| "LocalContext.java", |
| "CollectionAndSequence.java", |
| "Comment.java", |
| "DebugBreak.java", |
| "Expression.java", |
| "LibraryLoad.java", |
| "Macro.java", |
| "ReturnInstruction.java", |
| "StringArraySequence.java", |
| "TemplateElement.java", |
| "TemplateObject.java", |
| "TextBlock.java", |
| "ReturnInstruction.java", |
| "TokenMgrError.java" |
| ) |
| |
| val logExcludes = setOf( |
| "SLF4JLoggerFactory.java", |
| "CommonsLoggingLoggerFactory.java" |
| ) |
| |
| val compileJavaccDestDir = compileJavacc.get().destinationDirectory.get().asFile |
| setSource(source.filter { f -> |
| val fileName = f.name |
| val parentDirName = f.parentFile?.name |
| !(f.startsWith(compileJavaccDestDir) || |
| fileName.startsWith("_") && fileName.endsWith(".java") || |
| fileName == "SunInternalXalanXPathSupport.java" || |
| parentDirName == "core" && coreExcludes.contains(fileName) || |
| parentDirName == "template" && fileName == "EmptyMap.java" || |
| parentDirName == "log" && logExcludes.contains(fileName) |
| ) |
| }) |
| } |
| |
| tasks.named<Test>(JavaPlugin.TEST_TASK_NAME) { |
| val processResourcesName = sourceSets[SourceSet.TEST_SOURCE_SET_NAME].processResourcesTaskName |
| val resourcesDestDir = tasks.named<ProcessResources>(processResourcesName).get().destinationDir.toString() |
| systemProperty("freemarker.test.resourcesDir", resourcesDestDir) |
| |
| javaLauncher.set(javaToolchains.launcherFor { |
| languageVersion.set(JavaLanguageVersion.of(testRunnerJavaVersion)) |
| }) |
| } |
| |
| configurations { |
| compileOnly { |
| exclude(group = "xml-apis", module = "xml-apis") |
| } |
| testImplementation { |
| // Excluding to avoid test failures due to SAX parser conflict. |
| exclude(group = "pull-parser", module = "pull-parser") |
| } |
| |
| register("combinedClasspath") { |
| extendsFrom(named("jython25CompileOnly").get()) |
| extendsFrom(named("jsp21CompileOnly").get()) |
| } |
| |
| testImplementation { |
| extendsFrom(named("jython25CompileOnly").get()) |
| } |
| } |
| |
| tasks.named<Jar>(sourceSets.named(SourceSet.MAIN_SOURCE_SET_NAME).get().sourcesJarTaskName) { |
| from(compileJavacc.flatMap { it.sourceDirectory }) |
| from(resourceTemplatesDir) |
| |
| from(files("LICENSE", "NOTICE")) { |
| into("META-INF") |
| } |
| } |
| |
| |
| tasks.named<ProcessResources>("processResources") { |
| with(copySpec { |
| from(resourceTemplatesDir) |
| filter<org.apache.tools.ant.filters.ReplaceTokens>(mapOf("tokens" to versionFileTokens)) |
| }) |
| } |
| |
| val rmicOutputDir: java.nio.file.Path = buildDir.toPath().resolve("rmic") |
| |
| tasks.register("rmic") { |
| val rmicClasspath = objects.fileCollection() |
| |
| val sourceSet = sourceSets[SourceSet.MAIN_SOURCE_SET_NAME] |
| val compileTaskName = sourceSet.compileJavaTaskName |
| val compileTaskRef = tasks.named<JavaCompile>(compileTaskName) |
| |
| rmicClasspath.from(compileTaskRef.map { it.classpath }) |
| rmicClasspath.from(compileTaskRef.map { it.outputs }) |
| |
| inputs.files(rmicClasspath) |
| outputs.dir(rmicOutputDir) |
| |
| doLast { |
| val allClassesDirs = sourceSet.output.classesDirs |
| |
| val rmicRelSrcPath = listOf("freemarker", "debug", "impl") |
| val rmicSrcPattern = "Rmi*Impl.class" |
| |
| val rmicRelSrcPathStr = rmicRelSrcPath.joinToString(separator = File.separator) |
| val classesDir = allClassesDirs.find { candidateDir -> |
| Files.newDirectoryStream(candidateDir.toPath().resolve(rmicRelSrcPathStr), rmicSrcPattern).use { files -> |
| val firstFile = files.first { Files.isRegularFile(it) } |
| firstFile != null |
| } |
| } |
| |
| if (classesDir != null) { |
| ant.withGroovyBuilder { |
| "rmic"( |
| "classpath" to rmicClasspath.asPath, |
| "base" to classesDir.toString(), |
| "destDir" to rmicOutputDir.toString(), |
| "includes" to "${rmicRelSrcPath.joinToString("/")}/$rmicSrcPattern", |
| "verify" to "yes", |
| "stubversion" to "1.2" |
| ) |
| } |
| } else { |
| throw IllegalStateException("Couldn't find classes dir in ${allClassesDirs.asPath}") |
| } |
| } |
| } |
| |
| // This source set is only needed, because the OSGI plugin supports only a single sourceSet. |
| // We are deleting it, because otherwise it would fool IDEs that a source root has multiple owners. |
| val osgiSourceSet = sourceSets.create("osgi") { |
| val otherSourceSets = allSourceSetNames.map { name -> sourceSets.named(name).get() } |
| |
| java { |
| setSrcDirs(otherSourceSets.flatMap { s -> s.java.srcDirs }) |
| } |
| resources { |
| setSrcDirs(otherSourceSets.flatMap { s -> s.resources.srcDirs }) |
| } |
| } |
| val osgiClasspath = configurations.named("combinedClasspath").get() |
| osgiSourceSet.compileClasspath = osgiClasspath |
| osgiSourceSet.runtimeClasspath = osgiClasspath |
| sourceSets.remove(osgiSourceSet) |
| |
| tasks.named<Jar>(JavaPlugin.JAR_TASK_NAME) { |
| from(rmicOutputDir) |
| |
| configure<aQute.bnd.gradle.BundleTaskExtension> { |
| bndfile.set(file("osgi.bnd")) |
| |
| setSourceSet(osgiSourceSet) |
| properties.putAll(versionProperties) |
| properties.put("moduleOrg", project.group.toString()) |
| properties.put("moduleName", project.name) |
| } |
| } |
| |
| tasks.named<Javadoc>(JavaPlugin.JAVADOC_TASK_NAME) { |
| javadocTool.set(javaToolchains.javadocToolFor { |
| languageVersion.set(JavaLanguageVersion.of(javadocJavaVersion)) |
| }) |
| |
| val javadocEncoding = StandardCharsets.UTF_8 |
| |
| options { |
| locale = "en_US" |
| encoding = javadocEncoding.name() |
| windowTitle = "FreeMarker ${displayVersion} API" |
| |
| val extraOptions = this as StandardJavadocDocletOptions |
| extraOptions.links("https://docs.oracle.com/en/java/javase/16/docs/api/") |
| |
| extraOptions.author(true) |
| extraOptions.version(true) |
| extraOptions.docEncoding = javadocEncoding.name() |
| extraOptions.charSet = javadocEncoding.name() |
| extraOptions.docTitle = "FreeMarker ${displayVersion}" |
| |
| // There are too many to check |
| extraOptions.addStringOption("Xdoclint:-missing", "-quiet") |
| } |
| |
| classpath = files(configurations.named("combinedClasspath")) |
| |
| doLast { |
| val stylesheetPath = destinationDir!!.toPath().resolve("stylesheet.css") |
| logger.info("Fixing JDK 8 ${stylesheetPath}") |
| |
| val ddSelectorStart = "(?:\\.contentContainer\\s+\\.(?:details|description)|\\.serializedFormContainer)\\s+dl\\s+dd\\b.*?\\{[^\\}]*\\b" |
| val ddPropertyEnd = "\\b.+?;" |
| |
| val fixRules = listOf( |
| Pair(Regex("/\\* (Javadoc style sheet) \\*/"), "/\\* \\1 - JDK 8 usability fix regexp substitutions applied \\*/"), |
| Pair(Regex("@import url\\('resources/fonts/dejavu.css'\\);\\s*"), ""), |
| Pair(Regex("['\"]DejaVu Sans['\"]"), "Arial"), |
| Pair(Regex("['\"]DejaVu Sans Mono['\"]"), "'Courier New'"), |
| Pair(Regex("['\"]DejaVu Serif['\"]"), "Arial"), |
| Pair(Regex("(?<=[\\s,:])serif\\b"), "sans-serif"), |
| Pair(Regex("(?<=[\\s,:])Georgia,\\s*"), ""), |
| Pair(Regex("['\"]Times New Roman['\"],\\s*"), ""), |
| Pair(Regex("(?<=[\\s,:])Times,\\s*"), ""), |
| Pair(Regex("(?<=[\\s,:])Arial\\s*,\\s*Arial\\b"), ""), |
| Pair(Regex("(${ddSelectorStart})margin${ddPropertyEnd}"), "\\1margin: 5px 0 10px 20px;"), |
| Pair(Regex("(${ddSelectorStart})font-family${ddPropertyEnd}"), "\\1") |
| ) |
| |
| var stylesheetContent = String(Files.readAllBytes(stylesheetPath), javadocEncoding) |
| for (rule in fixRules) { |
| val prevContent = stylesheetContent |
| stylesheetContent = stylesheetContent.replace(rule.first, rule.second) |
| |
| if (prevContent == stylesheetContent) { |
| logger.warn("Javadoc style sheet did not contain anything matching: ${rule.first}") |
| } |
| } |
| |
| Files.write(stylesheetPath, stylesheetContent.toByteArray(javadocEncoding)) |
| } |
| } |
| |
| fun registerManualTask(taskName: String, locale: String, offline: Boolean) { |
| val manualTaskRef = tasks.register(taskName) { |
| val inputDir = file("freemarker-manual/src/main/docgen/${locale}") |
| inputs.dir(inputDir) |
| |
| val outputDir = buildDir.toPath().resolve("manual-${if (offline) "offline" else "online"}").resolve(locale) |
| outputs.dir(outputDir) |
| |
| description = if (offline) "Build the Manual for offline use" else "Build the Manual to be upload to the FreeMarker homepage" |
| |
| doLast { |
| val transform = org.freemarker.docgen.core.Transform() |
| transform.offline = offline |
| transform.sourceDirectory = inputDir |
| transform.destinationDirectory = outputDir.toFile() |
| |
| transform.execute() |
| } |
| } |
| |
| tasks.named(LifecycleBasePlugin.BUILD_TASK_NAME) { dependsOn(manualTaskRef) } |
| } |
| |
| registerManualTask("manualOffline", "en_US", true) |
| registerManualTask("manualOnline", "en_US", false) |
| |
| afterEvaluate { |
| // We are setting this, so the pom.xml will be generated properly |
| System.setProperty("line.separator", "\n") |
| } |
| |
| publishing { |
| repositories { |
| maven { |
| val snapshot = project.version.toString().endsWith("-SNAPSHOT") |
| val defaultDeployUrl = if (snapshot) "https://repository.apache.org/content/repositories/snapshots" else "https://repository.apache.org/service/local/staging/deploy/maven2" |
| setUrl(providers.gradleProperty("freemarkerDeployUrl").getOrElse(defaultDeployUrl)) |
| name = providers.gradleProperty("freemarkerDeployServerId").getOrElse("apache.releases.https") |
| } |
| } |
| |
| publications { |
| val mainPublication = create<MavenPublication>("main") { |
| from(components.getByName("java")) |
| pom { |
| withXml { |
| val headerComment = asElement().ownerDocument.createComment(""" |
| |
| Licensed to the Apache Software Foundation (ASF) under one |
| or more contributor license agreements. See the NOTICE file |
| distributed with this work for additional information |
| regarding copyright ownership. The ASF licenses this file |
| to you 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 |
| |
| http://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. |
| |
| """.trimIndent().prependIndent(" ") |
| ) |
| asElement().insertBefore(headerComment, asElement().firstChild) |
| } |
| |
| packaging = "jar" |
| name.set("Apache FreeMarker") |
| description.set(""" |
| |
| Google App Engine compliant variation of FreeMarker. |
| FreeMarker is a "template engine"; a generic tool to generate text output based on templates. |
| """.trimIndent().prependIndent(" ") + "\n " |
| ) |
| url.set("https://freemarker.apache.org/") |
| |
| organization { |
| name.set("Apache Software Foundation") |
| url.set("http://apache.org") |
| } |
| |
| licenses { |
| license { |
| name.set("Apache License, Version 2.0") |
| url.set("http://www.apache.org/licenses/LICENSE-2.0.txt") |
| distribution.set("repo") |
| } |
| } |
| |
| scm { |
| connection.set("scm:git:https://git-wip-us.apache.org/repos/asf/freemarker.git") |
| developerConnection.set("scm:git:https://git-wip-us.apache.org/repos/asf/freemarker.git") |
| url.set("https://git-wip-us.apache.org/repos/asf?p=freemarker.git") |
| tag.set("v${project.version}") |
| } |
| |
| issueManagement { |
| system.set("jira") |
| url.set("https://issues.apache.org/jira/browse/FREEMARKER/") |
| } |
| |
| mailingLists { |
| mailingList { |
| name.set("FreeMarker developer list") |
| post.set("dev@freemarker.apache.org") |
| subscribe.set("dev-subscribe@freemarker.apache.org") |
| unsubscribe.set("dev-unsubscribe@freemarker.apache.org") |
| archive.set("http://mail-archives.apache.org/mod_mbox/freemarker-dev/") |
| } |
| mailingList { |
| name.set("FreeMarker commit and Jira notifications list") |
| post.set("notifications@freemarker.apache.org") |
| subscribe.set("notifications-subscribe@freemarker.apache.org") |
| unsubscribe.set("notifications-unsubscribe@freemarker.apache.org") |
| archive.set("http://mail-archives.apache.org/mod_mbox/freemarker-notifications/") |
| } |
| mailingList { |
| name.set("FreeMarker management private") |
| post.set("private@freemarker.apache.org") |
| } |
| } |
| } |
| } |
| if (doSignPackages.get()) { |
| signing.sign(mainPublication) |
| } |
| } |
| } |
| |
| val distArchiveBaseName = "apache-${name}" |
| val distDir = buildDir.toPath().resolve("distributions") |
| |
| fun registerSignatureTask(archiveTask: TaskProvider<Tar>) { |
| val signTask = tasks.register(archiveTask.name + "Signature") { |
| val archiveFileRef = archiveTask.flatMap { task -> task.archiveFile } |
| |
| inputs.file(archiveFileRef) |
| outputs.file(archiveFileRef.map { f -> File(f.asFile.toString() + ".asc") }) |
| |
| doLast { |
| signing.sign(archiveTask.get().archiveFile.get().asFile) |
| } |
| } |
| |
| tasks.named(LifecycleBasePlugin.BUILD_TASK_NAME) { |
| dependsOn(archiveTask) |
| |
| if (doSignPackages.get()) { |
| dependsOn(signTask) |
| } |
| } |
| } |
| |
| fun registerCommonFiles(tar: Tar) { |
| tar.from("README.md") { |
| val displayVersion = versionProperties.get("version")!! |
| filter { content -> content.replace("{version}", displayVersion) } |
| } |
| |
| tar.from(files("NOTICE", "RELEASE-NOTES")) |
| } |
| |
| val distBin = tasks.register<Tar>("distBin") { |
| compression = Compression.GZIP |
| archiveBaseName.set(distArchiveBaseName) |
| destinationDirectory.set(distDir.toFile()) |
| archiveAppendix.set("bin") |
| |
| registerCommonFiles(this) |
| |
| from("src/dist/bin") { |
| exclude("rat-excludes") |
| } |
| |
| val jarFile = tasks.named<Jar>("jar").flatMap { jar -> jar.archiveFile } |
| from(jarFile) { |
| rename { name -> "freemarker.jar" } |
| } |
| |
| from(tasks.named("manualOffline")) { |
| into("documentation/_html") |
| } |
| |
| from(tasks.named(JavaPlugin.JAVADOC_TASK_NAME)) { |
| into("documentation/_html/api") |
| } |
| } |
| registerSignatureTask(distBin) |
| |
| val distSrc = tasks.register<Tar>("distSrc") { |
| compression = Compression.GZIP |
| archiveBaseName.set(distArchiveBaseName) |
| destinationDirectory.set(distDir.toFile()) |
| archiveAppendix.set("src") |
| |
| registerCommonFiles(this) |
| |
| from(files("LICENSE")) |
| |
| from(projectDir) { |
| includeEmptyDirs = false |
| include( |
| "src/**", |
| "*/src/**", |
| "**/*.kts", |
| "*.txt", |
| "osgi.bnd", |
| "rat-excludes" |
| ) |
| exclude( |
| "/build", |
| "/*/build", |
| "/gradle/wrapper", |
| "/gradlew*", |
| "**/*.bak", |
| "**/*.~*", |
| "*/*.*~" |
| ) |
| } |
| } |
| registerSignatureTask(distSrc) |
| |
| fun readExcludeFile(excludeFile: File): List<String> { |
| Files.lines(excludeFile.toPath()).use { lines -> |
| return lines |
| .map { it.trim() } |
| .filter { !it.startsWith("#") && !it.isEmpty() } |
| .collect(Collectors.toList()) |
| } |
| } |
| |
| tasks.withType<org.nosphere.apache.rat.RatTask>() { |
| doLast { |
| println("RAT (${name} task) report was successful: ${reportDir.get().asFile.toPath().resolve("index.html").toUri()}") |
| } |
| } |
| |
| tasks.named<org.nosphere.apache.rat.RatTask>("rat") { |
| inputDir.set(projectDir) |
| excludes.addAll(readExcludeFile(file("rat-excludes"))) |
| } |
| |
| fun registerDistRatTask(taskName: String, excludeFile: File, srcArchiveTaskRef: TaskProvider<Tar>) { |
| val inputTaskName = "${taskName}Prep" |
| val ratInputTask = tasks.register<Sync>(inputTaskName) { |
| dependsOn(srcArchiveTaskRef) |
| |
| destinationDir = buildDir.toPath().resolve("rat-prep").resolve(taskName).toFile() |
| from(tarTree(srcArchiveTaskRef.flatMap { it.archiveFile })) |
| } |
| |
| val ratTask = tasks.register<org.nosphere.apache.rat.RatTask>(taskName) { |
| dependsOn(ratInputTask) |
| |
| group = LifecycleBasePlugin.VERIFICATION_GROUP |
| description = "RAT report for the output of ${srcArchiveTaskRef.name}" |
| inputDir.set(layout.dir(ratInputTask.map { it.destinationDir })) |
| excludes.addAll(readExcludeFile(excludeFile)) |
| } |
| tasks.named(LifecycleBasePlugin.CHECK_TASK_NAME) { |
| dependsOn(ratTask) |
| } |
| } |
| |
| registerDistRatTask("ratDistBin", file("src/dist/bin/rat-excludes"), distBin) |
| registerDistRatTask("ratDistSrc", file("rat-excludes"), distSrc) |
| |
| // Choose the Jetty version very carefully, as it should implement the same Servlet API, JSP API, and EL API |
| // what we declare below, because the same classes will come from Jetty as well. For example, Jetty depends |
| // on org.mortbay.jasper:apache-el, which contains the javax.el classes, along with non-javax.el classes, so you |
| // can't even exclude it. Similarly, org.eclipse.jetty:apache-jsp contains the JSP API javax.servlet.jsp classes, |
| // yet again along with other classes. Anyway, this mess is temporary, as we will migrate to Jakarta, and only |
| // support that. |
| val jettyVersion = "9.4.53.v20231009" |
| val slf4jVersion = "1.6.1" |
| val springVersion = "2.5.6.SEC03" |
| val tagLibsVersion = "1.2.5" |
| |
| dependencies { |
| compileOnly("jaxen:jaxen:1.0-FCS") |
| compileOnly("saxpath:saxpath:1.0-FCS") |
| compileOnly("xalan:xalan:2.7.0") |
| compileOnly("jdom:jdom:1.0b8") |
| compileOnly("ant:ant:1.6.5") // FIXME: This could be moved to "jython20CompileOnly" |
| compileOnly("rhino:js:1.6R1") |
| compileOnly("avalon-logkit:avalon-logkit:2.0") |
| compileOnly("org.slf4j:slf4j-api:${slf4jVersion}") |
| compileOnly("org.slf4j:log4j-over-slf4j:${slf4jVersion}") |
| compileOnly("org.slf4j:jcl-over-slf4j:${slf4jVersion}") // FIXME: This seems to be unused |
| compileOnly("commons-logging:commons-logging:1.1.1") // FIXME: This seems to be unused |
| compileOnly("org.zeroturnaround:javarebel-sdk:1.2.2") |
| compileOnly("com.google.code.findbugs:annotations:3.0.0") |
| compileOnly("org.dom4j:dom4j:2.1.3") |
| |
| "jsp20CompileOnly"("javax.servlet.jsp:jsp-api:2.0") |
| "jsp20CompileOnly"("javax.servlet:servlet-api:2.4") |
| |
| "jsp21CompileOnly"(sourceSets["jsp20"].output) |
| "jsp21CompileOnly"("javax.servlet.jsp:jsp-api:2.1") |
| "jsp21CompileOnly"("javax.servlet:servlet-api:2.5") |
| |
| "jython20CompileOnly"("jython:jython:2.1") |
| |
| "jython22CompileOnly"(sourceSets["jython20"].output) |
| "jython22CompileOnly"("org.python:jython:2.2.1") |
| |
| "jython25CompileOnly"(sourceSets["jython20"].output) |
| "jython25CompileOnly"("org.python:jython:2.5.0") |
| |
| testImplementation("junit:junit:4.12") |
| testImplementation("org.hamcrest:hamcrest-library:1.3") |
| testImplementation("ch.qos.logback:logback-classic:1.1.2") |
| testImplementation("commons-io:commons-io:2.7") |
| testImplementation("com.google.guava:guava:29.0-jre") |
| testImplementation("org.eclipse.jetty:jetty-server:${jettyVersion}") |
| testImplementation("org.eclipse.jetty:jetty-webapp:${jettyVersion}") |
| testImplementation("org.eclipse.jetty:jetty-util:${jettyVersion}") |
| testImplementation("org.eclipse.jetty:apache-jsp:${jettyVersion}") |
| // Jetty also contains the servlet-api and jsp-api classes |
| |
| testImplementation("displaytag:displaytag:1.2") { |
| 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") |
| } |
| |
| // JSP JSTL (not included in Jetty): |
| testImplementation("org.apache.taglibs:taglibs-standard-impl:${tagLibsVersion}") |
| testImplementation("org.apache.taglibs:taglibs-standard-spec:${tagLibsVersion}") |
| |
| // Override Java 9 incompatible version (coming from displaytag): |
| testImplementation("commons-lang:commons-lang:2.6") |
| |
| testImplementation("org.springframework:spring-core:${springVersion}") { |
| exclude(group = "commons-logging", module = "commons-logging") |
| } |
| testImplementation("org.springframework:spring-test:${springVersion}") { |
| exclude(group = "commons-logging", module = "commons-logging") |
| } |
| } |
