plugins {

id 'io.github.ben-manes.versions' version '0.64.0'

id 'io.github.goooler.osgi' version '0.8.6'

id 'com.github.jk1.dependency-license-report' version '3.1.4'

id 'org.sonarqube' version '7.5.0.8588'

id 'org.apache.groovy-core'

id 'java-test-fixtures'

id 'org.apache.groovy-jacoco-aggregation'

id 'org.apache.groovy-dep-updates'

id 'org.apache.groovy-abi-check'

}

base {

archivesName = 'groovy'

}

groovyLibrary {

registerOptionalFeature 'grapes'

registerOptionalFeature 'logging'

registerOptionalFeature 'xstreamAst'

repackagedDependencies = [

'antlr', 'antlr-runtime', 'antlr4', 'antlr4-runtime', 'antlr4-annotations',

'asm', 'asm-commons', 'asm-tree', 'asm-util', 'picocli'

]

withGrooid(

"org.apache.groovy:groovy-grooid:${sharedConfiguration.groovyVersion.get()}",

['openbeans'] as Set,

[

'com.googlecode.openbeans.**': 'groovyjarjaropenbeans.@1',

'org.apache.harmony.beans.**': 'groovyjarjarharmonybeans.@1',

'java.beans.**': 'groovyjarjaropenbeans.@1'

],

[

'*': ['META-INF/NOTICE']

],

['META-INF/NOTICE', 'META-INF/INDEX.LIST'],

[

(project.relativePath(rootProject.file('notices/NOTICE-GROOIDJARJAR'))): 'META-INF/NOTICE'

],

[

// openbeans predates java.beans.Transient (Java 7); rewriting the annotation

// would point at a class that does not exist and break the Verifier (GROOVY-12391)

'java.beans.**': ['java.beans.Transient']

]

)

}

tasks.named('grooidJar') {

doLast {

def jar = new java.util.zip.ZipFile(archiveFile.get().asFile)

try {

['groovy/lang/GroovyObjectSupport.class', 'org/codehaus/groovy/classgen/Verifier.class'].each { entry ->

def bytes = new String(jar.getInputStream(jar.getEntry(entry)).bytes, 'ISO-8859-1')

if (bytes.contains('groovyjarjaropenbeans/Transient') || !bytes.contains('java/beans/Transient')) {

throw new GradleException("$entry in the grooid jar must keep referencing java.beans.Transient")

}

}

} finally {

jar.close()

}

}

}

groovyCore {

def supportClasses = ['Boolean','Char','Byte','Short','Int','Long','Float','Double'].collect {

'org.codehaus.groovy.transform.stc.StaticTypeCheckingSupport$'+it+'ArrayStaticTypesHelper'

}

bridgedClasses *supportClasses,

'groovy.lang.ExpandoMetaClass',

'org.codehaus.groovy.classgen.Verifier',

'org.codehaus.groovy.ast.tools.GeneralUtils',

'org.codehaus.groovy.ast.stmt.TryCatchStatement',

'org.codehaus.groovy.runtime.StringGroovyMethods',

'org.codehaus.groovy.runtime.DefaultGroovyMethods',

'org.codehaus.groovy.transform.stc.DefaultTypeCheckingExtension'

excludeFromJavadoc '**/GroovyRecognizer.java', '*.g4' // generated file

}

dependencies {

// Classic call-site runtime for tests that compile with indy=false (GROOVY-11158)

testRuntimeOnly projects.groovyCallsite

// the groovy.ast=xml AST dump uses XStream, an optional feature; supply it to the tests so

// XStreamUtils can be exercised (its permission handling in particular) rather than skipped

testRuntimeOnly "com.thoughtworks.xstream:xstream:${versions.xstream}", {

transitive = false

}

// for internal CLI usage

api "info.picocli:picocli:${versions.picocli}" // marked as api but manually excluded later in assemble.gradle - modules will use shaded version

// for internal usage of things like Opcode

api "org.ow2.asm:asm:${versions.asm}" // marked as api but manually excluded later in assemble.gradle - modules will use shaded version

// for internal usage by the parser but manually excluded later in assemble.gradle - modules will use shaded version

implementation "org.ow2.asm:asm-analysis:${versions.asm}"

implementation "org.ow2.asm:asm-commons:${versions.asm}"

implementation "org.ow2.asm:asm-tree:${versions.asm}"

implementation "org.ow2.asm:asm-util:${versions.asm}"

implementation "me.champeau.openbeans:openbeans:${versions.openbeans}"

implementation "me.sunlan:antlr4-runtime:${versions.antlr4}"

antlr "me.sunlan:antlr4:${versions.antlr4}"

grapesImplementation "org.apache.ivy:ivy:${versions.ivy}", {

transitive = false

}

loggingImplementation "org.jline:jansi:${versions.jline}"

xstreamAstImplementation "com.thoughtworks.xstream:xstream:${versions.xstream}", {

exclude group: 'jmock' , module: 'jmock'

exclude group: 'junit' , module: 'junit'

exclude group: 'xmlpull', module: 'xmlpull'

exclude group: 'xpp3' , module: 'xpp3_min'

}

testImplementation projects.groovyAnt

testImplementation projects.groovyHttpBuilder

testImplementation projects.groovyNio

testImplementation projects.groovyXml

testImplementation projects.groovyJson

testImplementation projects.groovyTest

testImplementation projects.groovyMacro

testImplementation projects.groovyDateutil

testImplementation projects.groovyTestJunit6 // for groovy.junit6.plugin.ForkedJvm

testImplementation "net.jcip:jcip-annotations:${versions.jcipAnnotations}"

testImplementation "com.github.javaparser:javaparser-core:${versions.javaParser}"

testImplementation "com.fasterxml.jackson.core:jackson-databind:${versions.jackson}"

testImplementation "com.fasterxml.jackson.dataformat:jackson-dataformat-yaml:${versions.jackson}"

testFixturesImplementation projects.groovyXml

testFixturesImplementation projects.groovyTest

testFixturesImplementation "org.junit.jupiter:junit-jupiter-api:${versions.junit6}"

testFixturesImplementation "xmlunit:xmlunit:${versions.xmlunit}"

tools "org.apache.ant:ant:${versions.ant}"

tools "org.jboss.bridger:bridger:${versions.bridger}"

// updated bridger dependencies to remove vulnerabilities:

tools "com.jcraft:jsch:0.1.55"

tools "commons-io:commons-io:2.22.0"

tools "org.apache.maven:maven-core:3.9.16"

tools "org.apache.maven.shared:maven-shared-utils:3.5.0"

tools "org.codehaus.plexus:plexus-utils:4.1.0"

// end

tools "org.ow2.asm:asm:${versions.asm}"

spotbugsPlugins 'com.h3xstream.findsecbugs:findsecbugs-plugin:1.14.0'

testRuntimeOnly(project(':')) {

because 'Tests are using Grapes'

capabilities {

requireCapability 'org.apache.groovy:groovy-grapes'

}

}

testRuntimeOnly projects.groovyGrapeIvy

}

configurations {

javadocClasspath.extendsFrom(

loggingImplementation,

xstreamAstImplementation,

grapesImplementation

)

groovyCompilerClasspath {

extendsFrom(implementation, compileOnly, grapesImplementation, loggingImplementation, xstreamAstImplementation, runtimeOnly)

}

}

allprojects {

tasks.withType(AbstractCopyTask).configureEach { task ->

// RepackageJarTask (Shadow-based) needs EXCLUDE so overlapping shaded deps

// (e.g. antlr4-runtime vs antlr4-annotations) do not warn/duplicate.

if (task instanceof org.apache.groovy.gradle.RepackageJarTask) {

task.duplicatesStrategy = DuplicatesStrategy.EXCLUDE

} else {

task.duplicatesStrategy = DuplicatesStrategy.WARN

}

}

}

tasks.named('jar') {

metaInf {

from("$projectDir/licenses/LICENSE-BASE")

from("$projectDir/notices/NOTICE-BASE")

rename '^([A-Z]+)-([^.]*)', '$1'

}

exclude '**/package-info.class'

}

tasks.named('repackageJar') {

// this artefact is the one that bundles the shaded antlr4 and asm, so it replaces

// the raw jar's plain pair with the JARJAR licensing

sourceExcludes = ['META-INF/LICENSE', 'META-INF/NOTICE']

metaInf {

from("$projectDir/licenses/LICENSE-JARJAR")

// LICENSE-JARJAR points at licenses/*.txt; ship those texts

into('licenses') {

from project.ext.licensePointerTexts("$projectDir/licenses/LICENSE-JARJAR")

}

from("$projectDir/notices/NOTICE-JARJAR")

rename '^([A-Z]+)-([^.]*)', '$1'

}

}

tasks.named('sourcesJar') {

duplicatesStrategy = DuplicatesStrategy.EXCLUDE

}

def extModuleFixtureDir = project.layout.projectDirectory.dir('src/test-fixtures/extmodule')

def extModuleOutputDir = project.layout.buildDirectory.dir('testFixtures/extmodule')

def extModuleRepoDir = extModuleOutputDir.map { it.dir('repo') }

def compileTestExtensionModule = tasks.register('compileTestExtensionModule', JavaCompile) {

classpath = files(tasks.named('jar'))

source fileTree(extModuleFixtureDir.dir('src/main/java'))

destinationDirectory = extModuleOutputDir.map { it.dir('classes') }

sourceCompatibility = sharedConfiguration.targetJavaVersion.get()

targetCompatibility = sharedConfiguration.targetJavaVersion.get()

}

def testExtensionModuleJar = tasks.register('testExtensionModuleJar', Jar) {

description = 'Builds a sample extension module used in tests'

archiveBaseName = 'module-test'

archiveVersion = '1.4'

from compileTestExtensionModule

from extModuleFixtureDir.dir('src/main/resources')

// emulate Maven repo format for output

destinationDirectory = extModuleRepoDir.map { it.dir("jars/module-test/module-test/${archiveVersion.get()}") }

}

dependencies {

testRuntimeOnly files(extModuleRepoDir)

}

tasks.named('test') {

dependsOn testExtensionModuleJar

}

if (!JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_17)) {

logger.lifecycle '''

}

apply from: 'gradle/licenses.gradle'

apply from: 'gradle/idea.gradle'

apply from: 'gradle/eclipse.gradle'

if (file('user.gradle').exists()) {

apply from: 'user.gradle'

}

licenseReport {

excludeGroups = [

'org.multiverse' // we never include this optional dependency of an optional dependency

]

}

gradle.taskGraph.whenReady { graph ->

if (graph.hasTask(':generateLicenseReport') && gradle.startParameter.parallelProjectExecutionEnabled) {

throw new GradleException('generateLicenseReport is not compatible with parallel builds (Gradle 9+ issue). Please re-run with: ./gradlew generateLicenseReport --no-parallel')

}

}

sonarqube {

properties {

property 'sonar.projectName', 'Apache Groovy'

property 'sonar.projectKey', 'apache_groovy'

property 'sonar.organization', 'apache'

property 'sonar.host.url', 'https://sonarcloud.io'

property 'sonar.cpd.exclusions', '**/*'

property 'sonar.exclusions', '**/build/**,**/dashboard/**,**/*.html'

property 'sonar.coverage.jacoco.xmlReportPaths', layout.buildDirectory.file('reports/jacoco/jacocoAllReport/jacocoAllReport.xml').get().asFile.absolutePath

}

}

artifacts {

grapesRuntimeElements file: jar.archiveFile.get().asFile, type: 'jar'

xstreamAstRuntimeElements file: jar.archiveFile.get().asFile, type: 'jar'

loggingRuntimeElements file: jar.archiveFile.get().asFile, type: 'jar'

}

tasks.register('validateActions', org.apache.groovy.gradle.ValidateActionsTask) {

group = 'verification'

workflowFiles.from(fileTree(rootProject.file('.github/workflows')) {

include '*.yml'

include '*.yaml'

})

}