import org.apache.tools.ant.filters.ReplaceTokens

project.ext {

title = "Apache Zest™ (Java Edition) SDK"

description = "Apache Zest™ (Java Edition) is a framework for domain centric application development, including evolved concepts from AOP, DI and DDD."

testFailures = [ ]

mainClassName = 'org.apache.zest.container.Main'

groovycMain_mx = "700m"

groovycMain_permSize = "512m"

groovycMain_maxPermSize = "512m"

}

buildscript {

repositories {

maven { url "https://plugins.gradle.org/m2/" }

jcenter()

}

dependencies {

classpath 'gradle.plugin.org.nosphere.apache:creadur-rat-gradle:0.2.1'

classpath 'gradle.plugin.org.nosphere.honker:honker-gradle:0.2.2'

classpath 'org.hibernate.build.gradle:gradle-maven-publish-auth:2.0.1'

}

}

apply plugin: 'java'

apply plugin: 'idea'

apply plugin: 'signing'

apply plugin: 'maven'

apply plugin: 'maven-publish-auth'

apply plugin: 'project-report'

apply from: 'libraries.gradle'

apply plugin: 'org.nosphere.apache.rat'

targetCompatibility = "1.8"

sourceCompatibility = "1.8"

project.ext {

releaseSpec = new org.apache.zest.gradle.plugin.ModuleReleaseSpecification()

releaseApprovedProjects = allprojects.findAll( { p -> rootProject.releaseSpec.satisfiedBy( p ) } )

}

project.ext.skipSigning = rootProject.hasProperty( 'skipSigning' ) ? rootProject.skipSigning : false

rat {

onlyIf { version != '0' }

excludes = [

'**/.DS_Store/**', '**/._*',

// Git Files

'**/.git/**', '**/.gitignore',

// Gradle Files

'gradle/wrapper/**', '**/gradlew', '**/gradlew.bat', '**/.gradle/**',

// Build Output

'**/build/**', '**/derby.log', 'out/**',

// IDE Files

'**/.idea/**', '**/*.iml', '**/*.ipr', '**/*.iws',

'**/.settings/**', '**/.classpath', '**/.project',

'**/.gradletasknamecache', '**/private/cache/**',

'**/.nb-gradle-properties', '**/.nb-gradle/**',

// JSON files are not allowed to have comments, according to http://www.json.org/ and http://www.ietf.org/rfc/rfc4627.txt

'**/*.json',

// Various Text Resources

'**/README.*','**/README*.*', '**/TODO',

'**/src/main/resources/**/*.txt',

'**/src/test/resources/**/*.txt',

'libraries/rest-server/src/main/resources/**/*.htm',

'libraries/rest-server/src/main/resources/**/*.atom',

'tools/qidea/src/main/resources/**/*.ft',

'tools/qidea/src/main/resources/**/*.template',

// Graphic Resources

'**/*.svg', '**/*.gif', '**/*.png', '**/*.jpg', '**/*.psd',

// Keystores

'**/*.jceks',

// Syntax Highlighter - MIT

'manual/**/sh*.css', 'manual/**/sh*.js',

// jQuery & plugins - MIT

'manual/**/jquery*.js',

// W3C XML Schemas - W3C Software License

'samples/rental/src/main/resources/*.xsd',

// templates that will become the user's source files, should not have license headers

'tools/shell/src/dist/etc/templates/**',

]

}

idea.project.ipr {

withXml { provider ->

provider.node.component.find { it.@name == 'VcsDirectoryMappings' }.mapping.@vcs = 'Git'

}

}

def repos_urls = [

mavenCentral: "http://repo1.maven.org/maven2/",

ops4j: "http://repository.ops4j.org/maven2/",

restlet: 'http://maven.restlet.org/',

clojars: "http://clojars.org/repo/",

]

allprojects {

apply plugin: 'eclipse'

apply plugin: 'idea'

apply plugin: 'signing'

apply plugin: 'java'

apply plugin: 'project-report'

apply plugin: 'maven'

apply plugin: 'org.nosphere.honker'

defaultTasks 'classes', 'test'

group = name == 'org.apache.zest' ? 'org.apache.zest' : name.substring( 0, name.lastIndexOf( '.' ) )

if( version == 'unspecified' ) {

version = System.properties.version ?: "0"

}

// UTF-8 For all compilations and javadocs

// Deprecation warnings for all compilations

// Unchecked warnings for non-test core compilations

tasks.withType(JavaCompile) {

options.encoding = 'UTF-8'

options.compilerArgs << "-Xlint:deprecation"

}

if("core".equals(group)) {

tasks.matching({ task -> task instanceof JavaCompile && !task.name.contains('test') }).

each({ task -> task.options.compilerArgs << "-Xlint:unchecked" })

}

tasks.withType(Javadoc) {

options.encoding = 'UTF-8'

options.docEncoding = 'UTF-8'

options.charSet = 'UTF-8'

options.noTimestamp = true

options.links = [

'http://docs.oracle.com/javase/8/docs/api/',

'https://stleary.github.io/JSON-java/',

'http://junit.org/junit4/javadoc/latest/'

]

// exclude '**/internal/**'

}

repositories {

mavenCentral()

maven { name 'ops4j-repo'; url repos_urls.ops4j }

maven { name 'restlet-repo'; url repos_urls.restlet }

maven { name 'clojars-repo'; url repos_urls.clojars }

}

// Artifact upload global configuration BEGIN -----------------------------

def uploadSnapshots = version.contains("SNAPSHOT")

def uploadReleases = ! uploadSnapshots

// By default RELEASES are signed, SNAPSHOTS are not

// Signing can be turned on or off by setting the uploadSigned property

def uploadSigned = rootProject.hasProperty('uploadSigned') \

? rootProject.uploadSigned : uploadReleases \

? true : false

// By default RELEASES must satisfy ReleaseSpecification, SNAPSHOT don't

// ReleaseSpecification usage can be turned on or off by setting the uploadReleaseSpec property

def uploadReleaseSpec = rootProject.hasProperty('uploadReleaseSpec') \

? rootProject.uploadReleaseSpec : uploadReleases \

? true : false

// By default RELEASES and SNAPSHOTS are uploaded using HTTP

// Used Wagon can be overriden by setting the uploadWagon property

// def wagonSSH = "org.apache.maven.wagon:wagon-ssh:2.2"

// def wagonWEBDAV = "org.apache.maven.wagon:wagon-webdav:1.0-beta-2"

def wagonHTTP = "org.apache.maven.wagon:wagon-http:2.2"

def uploadWagon = rootProject.hasProperty('uploadWagon') \

? rootProject.uploadWagon : wagonHTTP

// By default RELEASES and SNAPSHOTS are uploaded to Apache Nexus

// Target repository can be overriden by setting the uploadRepository property

def releasesRepositoryName = "apache.releases.https"

def releasesRepository = "https://repository.apache.org/service/local/staging/deploy/maven2"

def snapshotsRepositoryName = "apache.snapshots.https"

def snapshotsRepository = "https://repository.apache.org/content/repositories/snapshots"

def uploadRepositoryName = rootProject.hasProperty('uploadRepositoryName') \

? rootProject.uploadRepositoryName \

: uploadReleases ? releasesRepositoryName : snapshotsRepositoryName

def uploadRepository = rootProject.hasProperty('uploadRepository') \

? rootProject.uploadRepository \

: uploadReleases ? releasesRepository : snapshotsRepository

// No username/password is provided by default

// If needed set them using the uploadUsername and uploadPassword properties

def uploadUsername = rootProject.hasProperty('uploadUsername') ? rootProject.uploadUsername : null

def uploadPassword = rootProject.hasProperty('uploadPassword') ? rootProject.uploadPassword : null

// Artifact upload global configuration END -------------------------------

configurations {

archives

deployerJars

provided

compile.extendsFrom provided

runtime.extendsFrom compile

}

dependencies {

testCompile( libraries.ant )

testCompile( libraries.ant_junit )

testCompile( libraries.junit )

testRuntime( libraries.asm, libraries.asm_commons, libraries.asm_util )

deployerJars( uploadWagon )

}

test.onlyIf { !project.hasProperty( 'skipTests' ) }

test {

testLogging {

info {

exceptionFormat "full"

}

}

}

sourceSets {

main {

output.dir( honkerGenDependencies.outputDir, builtBy: honkerGenDependencies )

output.dir( honkerGenLicense.outputDir, builtBy: honkerGenLicense )

output.dir( honkerGenNotice.outputDir, builtBy: honkerGenNotice )

}

docs {

resources {

srcDir 'src/docs'

}

}

}

honker {

// Project License, applied to all submodules

license 'Apache 2'

// Dependencies (transitive or not) with no license information, overriding them

licenseOverride { candidate ->

if( candidate.group == 'asm' || candidate.module == 'prefuse-core' ) {

candidate.license = 'BSD 3-Clause'

}

if( candidate.group == 'org.apache.httpcomponents'

|| candidate.group == 'net.java.dev.jna'

|| candidate.group == 'lucene'

|| candidate.group == 'jdbm'

|| candidate.group == 'org.osgi'

|| candidate.group.startsWith( 'org.restlet' ) ) {

candidate.license = 'Apache 2'

}

}

}

honkerGenNotice {

header = 'Apache Zest'

footer = 'This product includes software developed at\nThe Apache Software Foundation (http://www.apache.org/).\n'

}

check.dependsOn honkerCheck

project.ext {

javaDir = new File( "$projectDir/src/main/java" )

scalaDir = new File( "$projectDir/src/main/scala" )

groovyDir = new File( "$projectDir/src/main/groovy")

documentationDir = new File( "$projectDir/src/docs" )

testJavaDir = new File( "$projectDir/src/tests/java" )

testScalaDir = new File( "$projectDir/src/tests/scala" )

testGroovyDir = new File( "$projectDir/src/tests/groovy")

}

// Actual code projects BEGIN -------------------------------------------

if( ext.javaDir.isDirectory() || ext.scalaDir.isDirectory() || ext.groovyDir.isDirectory() ||

ext.testJavaDir.isDirectory() || ext.testScalaDir.isDirectory() || ext.testGroovyDir.isDirectory() )

{

apply plugin: 'jacoco'

apply plugin: 'osgi'

apply plugin: VersionClass

apply plugin: AsciidocBuildInfo

jar {

manifest {

license = 'http://www.apache.org/licenses/LICENSE-2.0.txt'

docURL = 'https://zest.apache.org'

description = project.description ?: 'Apache Zest™ (Java Edition) is a platform for Composite Oriented Programming'

vendor = 'The Apache Software Foundation, https://www.apache.org'

instruction '-debug', 'true'

}

}

signing {

required { rootProject.version != '0' && uploadSigned }

sign configurations.archives

}

signArchives.onlyIf { !rootProject.skipSigning }

task sourceJar( type: Jar ) {

classifier = "sources"

from sourceSets.main.allSource

}

task testSourceJar( type: Jar ) {

classifier = "testsources"

from sourceSets.test.allSource

}

task javadocJar( type: Jar ) {

classifier = "javadoc"

from javadoc.destinationDir

dependsOn javadoc

}

artifacts {

archives sourceJar, testSourceJar, javadocJar

}

def testProperties = [

'proxySet': System.properties[ 'proxySet' ],

'proxyHost': System.properties[ 'proxyHost' ],

'proxyPort': System.properties[ 'proxyPort' ] ]

test {

maxHeapSize = "1024m"

systemProperties = testProperties

systemProperties['user.dir'] = workingDir // GRADLE-2859

ignoreFailures = true

reports.html.enabled(true)

afterSuite { descriptor, result ->

if( result.resultType == TestResult.ResultType.FAILURE )

{

rootProject.ext.testFailures << project

}

}

}

jacoco {

toolVersion = '0.7.5.201505241946'

}

// Dependency Report generate only the runtime configuration

// The report is packaged in the SDK distributions

dependencyReport {

configurations = [ project.configurations.runtime ]

}

task minBuild {

dependsOn classes

dependsOn test

}

}

// Actual code projects END ---------------------------------------------

// Upload Archives - Artifact Deployment

uploadArchives.doFirst {

if( version == "0" )

{

throw new GradleException( "'version' must be given as a system property to perform a release." )

}

}

uploadArchives.onlyIf { ( !uploadReleaseSpec || ( releaseApprovedProjects.contains( project ) || project == rootProject ) ) && !project.hasProperty( 'skipUpload' ) }

uploadArchives {

dependsOn check

repositories.mavenDeployer {

if( uploadSigned )

beforeDeployment { MavenDeployment deployment -> signing.signPom( deployment ) }

configuration = configurations.deployerJars

repository(id: uploadRepositoryName, url: uploadRepository) {

if( uploadUsername )

authentication(userName: uploadUsername, password: uploadPassword)

}

snapshotRepository(id: uploadRepositoryName, url: uploadRepository) {

if( uploadUsername )

authentication(userName: uploadUsername, password: uploadPassword)

}

}

}

apply from: "$rootProject.projectDir/maven-compat.gradle"

apply plugin: 'maven-publish-auth' // Bug in maven-publish-auth require apply after uploadArchives setup

idea.module.iml {

whenMerged { module ->

module.dependencies*.exported = true

}

}

} // allprojects END -------------------------------------------------------

task goOffline {

doLast {

allprojects.configurations.flatten()*.resolvedConfiguration

}

}

gradle.taskGraph.whenReady {taskGraph ->

taskGraph.allTasks.last().doLast {

if( rootProject.ext.testFailures )

{

println "\nTest failures in:"

rootProject.ext.testFailures.unique().each { project -> println " " + project.name }

println ""

throw new RuntimeException( "There was TEST FAILURES!! See list above." )

}

}

}

task globalTestReport( type: TestReport ) {

destinationDir = file("$buildDir/reports/tests")

reportOn subprojects*.test

}

test {

dependsOn subprojects*.test, globalTestReport

reports.html.enabled = false

}

configurations {

jacoco

}

dependencies {

jacoco 'org.jacoco:org.jacoco.ant:0.7.5.201505241946'

}

task coverageReport {

dependsOn subprojects*.test

def outputPath = "build/reports/coverage"

inputs.dir subprojects.collect { p -> "${p.buildDir.path}/jacoco" }

outputs.dir outputPath

doLast {

def coveredProjects = subprojects.findAll { p -> new File( "${p.buildDir.path}/jacoco" ).exists() }

def coreProjects = coveredProjects.findAll { p -> p.name.startsWith('org.apache.zest.core' ) }

def libProjects = coveredProjects.findAll { p -> p.name.startsWith( 'org.apache.zest.lib' ) }

def extProjects = coveredProjects.findAll { p -> p.name.startsWith( 'org.apache.zest.ext' ) }

def toolsProjects = coveredProjects.findAll { p -> p.name.startsWith( 'org.apache.zest.tool' ) }

def tutoProjects = coveredProjects.findAll { p -> p.name.startsWith( 'org.apache.zest.tuto' ) }

def samplesProjects = coveredProjects.findAll { p -> p.name.startsWith( 'org.apache.zest.sample' ) }

ant {

taskdef name:'jacocoreport', classname: 'org.jacoco.ant.ReportTask', classpath: configurations.jacoco.asPath

mkdir dir: outputPath

jacocoreport {

executiondata {

coveredProjects.collect { p -> fileset( dir: "${p.buildDir.path}/jacoco" ) { include( name: '*.exec' ) } }

}

structure( name: "Apache Zest™ (Java Edition) SDK" ) {

group( name: "Core" ) {

classfiles { coreProjects.collect { p -> fileset dir: "${p.buildDir.path}/classes/main" } }

sourcefiles { coreProjects.collect { p -> fileset dir: "${p.projectDir.path}/src/main/java" } }

}

group( name: "Libraries" ) {

classfiles { libProjects.collect { p -> fileset dir: "${p.buildDir.path}/classes/main" } }

sourcefiles { libProjects.collect { p -> fileset dir: "${p.projectDir.path}/src/main/java" } }

}

group( name: "Extensions" ) {

classfiles { extProjects.collect { p -> fileset dir: "${p.buildDir.path}/classes/main" } }

sourcefiles { extProjects.collect { p -> fileset dir: "${p.projectDir.path}/src/main/java" } }

}

group( name: "Tools" ) {

classfiles { toolsProjects.collect { p -> fileset dir: "${p.buildDir.path}/classes/main" } }

sourcefiles { toolsProjects.collect { p -> fileset dir: "${p.projectDir.path}/src/main/java" } }

}

group( name: "Tutorials" ) {

classfiles { tutoProjects.collect { p -> fileset dir: "${p.buildDir.path}/classes/main" } }

sourcefiles { tutoProjects.collect { p -> fileset dir: "${p.projectDir.path}/src/main/java" } }

}

group( name: "Samples" ) {

classfiles { samplesProjects.collect { p -> fileset dir: "${p.buildDir.path}/classes/main" } }

sourcefiles { samplesProjects.collect { p -> fileset dir: "${p.projectDir.path}/src/main/java" } }

}

}

csv destfile: "${outputPath}/jacoco.csv", encoding: "UTF-8"

xml destfile: "${outputPath}/jacoco.xml", encoding: "UTF-8"

html destdir: outputPath, encoding: "UTF-8", locale: "en", footer: "Apache Zest™ (Java Edition) SDK"

}

}

}

}

check.dependsOn coverageReport

task javadocs( type: Javadoc ) {

options.docFilesSubDirs = true

options.encoding = "UTF-8"

options.overview = "${rootProject.projectDir}/src/javadoc/overview.html"

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

def apiSources = releaseApprovedProjects.findAll( { project ->

( project.name.startsWith( 'org.apache.zest.core' ) && !project.name.startsWith( 'org.apache.zest.core.runtime' ) ) ||

project.name.startsWith( 'org.apache.zest.library' ) ||

project.name.startsWith( 'org.apache.zest.extension' ) ||

project.name.startsWith( 'org.apache.zest.tool' )

} )

source apiSources.collect { project ->

project.sourceSets.main.allJava

}

destinationDir = project.file( "$project.docsDir/javadocs" )

// Might need a classpath

classpath = files( apiSources.collect { project ->

project.sourceSets.main.compileClasspath

} )

options.group( [ "Core API": [ "org.apache.zest.api", "org.apache.zest.api.*", "org.apache.zest.io", "org.apache.zest.functional" ],

"Core Bootstrap": [ "org.apache.zest.bootstrap", "org.apache.zest.bootstrap.*" ],

"Core SPI": [ "org.apache.zest.spi", "org.apache.zest.spi.*" ],

"Libraries": [ "org.apache.zest.library.*" ],

"Extensions": [ "org.apache.zest.valueserialization.*", "org.apache.zest.entitystore.*", "org.apache.zest.index.*", "org.apache.zest.metrics.*", "org.apache.zest.cache.*", "org.apache.zest.migration", "org.apache.zest.migration.*" ],

"Tools": [ "org.apache.zest.tools.*", "org.apache.zest.envisage", "org.apache.zest.envisage.*" ],

"Test Support": [ "org.apache.zest.test", "org.apache.zest.test.*" ]

] )

}

task archiveJavadocs(type: Copy ) {

dependsOn javadocs

if( rootProject.version == '0' || rootProject.version.contains( "SNAPSHOT" ) )

{

into( "$rootProject.projectDir/../zest-web/site/content/java/develop/javadocs/" )

}

else

{

into( "$rootProject.projectDir/../zest-web/site/content/java/$version/javadocs/" )

}

from( 'build/docs/javadoc/' )

}

task buildAll( dependsOn: [

javadocs,

check,

jar,

subprojects*.dependencyReport,

subprojects*.assemble,

':org.apache.zest.manual:website'

] ) { }

def licenseHeader_wrap( base, top, left, bottom ) {

( top ? "$top\n" : '' ) + base.readLines().collect{ "${left}${it}" }.join( '\n' ) + '\n' + ( bottom ? "$bottom\n" : '' )

}

def licenseHeader( flavour ) {

def base = project.file( 'etc/header.txt' ).text

def header

switch( flavour ) {

case 'java': case 'groovy': case 'scala': case 'js':

header = licenseHeader_wrap( base, '/*', ' * ', ' */' ) ; break

case 'xml': case 'html':

header = licenseHeader_wrap( base, '<!--', ' ', '-->' ) ; break

case 'txt': case 'shell': case 'python': case 'ruby':

header = licenseHeader_wrap( base, null, '# ', null ) ; break

case 'adoc': case 'asciidoc':

header = licenseHeader_wrap( base, null, '// ', null ) ; break

default:

header = base

}

header

}

task generateBinDistGoOfflineHelpers {

def goOfflineGradleFile = file( 'build/go-offline-helpers/go-offline.gradle' )

def goOfflinePomFile = file( 'build/go-offline-helpers/go-offline.pom')

outputs.file goOfflineGradleFile

outputs.file goOfflinePomFile

doLast {

def goOfflineGradle = licenseHeader( 'java' )

goOfflineGradle += '// This gradle build file has the sole purpose of downloading all dependencies in a directory relative to this file named \'dependencies\'.\n'

goOfflineGradle += '// Use the following command: gradle -b go-offline.gradle download\n'

goOfflineGradle += 'apply plugin: \'java\'\nconfigurations { download }\nrepositories {\n'

def goOfflinePom = licenseHeader( 'xml' )

goOfflinePom += '<project>\n <modelVersion>4.0.0</modelVersion>\n'

goOfflinePom += " <groupId>org.apache.zest</groupId>\n <artifactId>go-offline-helper</artifactId>\n <version>$version</version>\n"

goOfflinePom += ' <packaging>pom</packaging>\n'

goOfflinePom += ' <!--\n This pom has the sole purpose of downloading all dependencies in a directory relative to this file named \'dependencies\'.\n'

goOfflinePom += ' Use the following command:\n\n mvn -f go-offline.pom validate\n -->\n <repositories>\n'

def repoCount = 1

repos_urls.each { repo_url ->

goOfflineGradle += " maven { url '${repo_url.value}' }\n"

goOfflinePom += " <repository><id>go-offline-repo-$repoCount</id><url>${repo_url.value}</url></repository>\n"

repoCount++

}

goOfflineGradle += '}\ndependencies {\n'

goOfflinePom += ' </repositories>\n <dependencies>\n'

// Do the global dependency resolution here so there won't be any suprise when using the helpers

// This also allow to apply the resolution strategy defined in libraries.gradle

// WARN some of our modules depends on != versions of some artifacts, this resolution flatten this using the most up to date

def allRuntimeDeps = releaseApprovedProjects.collect{ it.configurations.runtime.allDependencies }.flatten()

rootProject.configurations.create( 'goOfflineHelpers' )

rootProject.dependencies { allRuntimeDeps.each{ goOfflineHelpers it } }

rootProject.configurations.goOfflineHelpers.incoming.resolutionResult.allComponents.each { comp ->

def depCoords = "${comp.moduleVersion.group}:${comp.moduleVersion.name}:${comp.moduleVersion.version}"

if( !comp.moduleVersion.group.startsWith( 'org.apache.zest' ) ) {

goOfflineGradle += " download( '$depCoords' ) { transitive = false }\n"

goOfflinePom += " <dependency><groupId>${comp.moduleVersion.group}</groupId><artifactId>${comp.moduleVersion.name}</artifactId><version>${comp.moduleVersion.version}</version></dependency>\n"

}

}

goOfflineGradle += """}

goOfflinePom += """ </dependencies>\n <build><plugins><plugin>

goOfflineGradleFile.parentFile.mkdirs()

goOfflinePomFile.parentFile.mkdirs()

goOfflineGradleFile.text = goOfflineGradle

goOfflinePomFile.text = goOfflinePom

}

}

def srcDistFilesImages = copySpec {

from '.'

include '*.txt'

include 'doap.rdf'

include '*.gradle'

include 'gradlew*'

include 'gradle/**'

include 'etc/**'

include 'buildSrc/**'

include 'src/**'

releaseApprovedProjects.each { p ->

def relPath = new File( project.projectDir.toURI().relativize( p.projectDir.toURI() ).toString() )

include "$relPath/**"

}

include 'manual/**'

include 'samples/**'

include 'tests/**'

include 'tutorials/**'

include 'tools/shell/**'

// Filtered, see below

exclude 'settings.gradle'

exclude 'gradle.properties'

// Excludes

exclude '**/build/' // Build output

exclude 'derby.log' // Derby test garbage

exclude '**/*.iml' // IDEA files

exclude '**/*.ipr' // IDEA files

exclude '**/*.iws' // IDEA files

exclude '**/.idea' // IDEA files

exclude '**/out/*' // IDEA build output

exclude '**/.classpath' // Eclipse files

exclude '**/.project' // Eclipse files

exclude '**/.settings' // Eclipse files

exclude '**/.nb-gradle/' // Netbeans files

exclude '**/.nb-gradle*' // Netbeans files

exclude '**/.git/' // Git directories

exclude '**/.git*' // Git files

exclude '**/.gradle/' // Gradle management files

exclude '**/.gradletasknamecache' // Gradle cache

into '.'

}

task srcDistFilteredFiles() {

// Generates various files for the source distribution

// - settings.gradle

// - gradle.properties to set version !

def filteredDir = new File( "$project.buildDir/tmp/srcDistFilteredFiles")

outputs.file filteredDir

doLast {

// Settings

def settingsFile = new File( filteredDir, 'settings.gradle' )

settingsFile.parentFile.mkdirs()

def filteredSettings = ''

project.file( 'settings.gradle' ).readLines().each { line ->

if( line.contains( '\'libraries:' ) || line.contains( '\'extensions:' ) || line.contains( '\'tools:' ) ) {

def accepted = false

releaseApprovedProjects.collect{it.projectDir}.each { acceptedProjectDir ->

if( line.contains( "'${acceptedProjectDir.parentFile.name}:${acceptedProjectDir.name}'" ) ) {

accepted = true

}

}

if( accepted ) {

filteredSettings += "$line\n"

}

} else {

filteredSettings += "$line\n"

}

}

settingsFile.text = filteredSettings

// gradle.properties

def gradlePropsFile = new File( filteredDir, 'gradle.properties' )

gradlePropsFile.parentFile.mkdirs()

gradlePropsFile.text = project.file( 'gradle.properties' ).text + "\nskipSigning=true\nskipAsciidocIfAbsent=true\n\nversion=$version\n"

}

}

def srcDistFilteredFilesImage = copySpec {

from srcDistFilteredFiles

into '.'

}

def srcDistImage = copySpec {

into "apache-zest-java-$version-src"

with srcDistFilesImages

with srcDistFilteredFilesImage

}

def reportsDistImage = copySpec {

from "$buildDir/reports"

into( "docs/reports" )

}

def docsImage = copySpec {

from "build/docs"

from "manual/build/docs/website"

into( "docs" )

}

def runtimeDependenciesListImage = copySpec {

releaseApprovedProjects.collect { p ->

into( "libs/" ) {

from "$p.buildDir/reports/project/dependencies.txt"

rename 'dependencies.txt', "${p.name}-${p.version}-runtime-deps.txt"

}

}

into( '.' ) {

from generateBinDistGoOfflineHelpers.outputs

}

}

def libsImage = copySpec {

releaseApprovedProjects.collect { proj ->

into( "libs/" ) {

from proj.configurations.archives.artifacts.files

exclude '**-testsources.jar'

exclude '**/*.asc'

}

}

}

def extraDistTextImage = copySpec {

releaseApprovedProjects.collect { p ->

from fileTree(dir: "$p.projectDir/src/dist/", include: '**', exclude: "**/*.jar*")

eachFile {

filter(ReplaceTokens, tokens: [version: version])

}

}

into( "." )

}

def extraDistBinImage = copySpec {

releaseApprovedProjects.collect { p ->

from "$p.projectDir/src/dist/"

include "**/*.jar"

include "**/*.jar_"

}

into( "." )

}

def binDistNoticesImage = copySpec {

from( "$projectDir/LICENSE.txt")

from( "$projectDir/src/bin-dist" )

into( "." )

}

def binDistImage = copySpec {

into "apache-zest-java-$version-bin"

with binDistNoticesImage

with docsImage

with reportsDistImage

with runtimeDependenciesListImage

with extraDistTextImage

with extraDistBinImage

with libsImage

}

task zipSources( type: Zip ) {

baseName = 'apache-zest-java'

with srcDistImage

classifier = 'src'

}

task tarSources( type: Tar ) {

baseName = 'apache-zest-java'

with srcDistImage

compression = Compression.GZIP

classifier = 'src'

}

task zipBinaries( type: Zip, dependsOn: buildAll ) {

baseName = 'apache-zest-java'

classifier = 'bin'

with binDistImage

}

task tarBinaries( type: Tar, dependsOn: buildAll ) {

baseName = 'apache-zest-java'

classifier = 'bin'

compression = Compression.GZIP

with binDistImage

}

tasks.withType( Zip ) { task ->

task.doLast {

ant.checksum file: task.archivePath, algorithm: 'MD5'

ant.checksum file: task.archivePath, algorithm: 'SHA-512'

}

}

tasks.withType( Tar ) { task ->

task.doLast {

ant.checksum file: task.archivePath, algorithm: 'MD5'

ant.checksum file: task.archivePath, algorithm: 'SHA-512'

}

}

artifacts {

archives zipSources, tarSources, zipBinaries, tarBinaries

}

signing {

required { rootProject.version != '0' && !rootProject.version.contains( 'SNAPSHOT' ) }

sign configurations.archives

}

signArchives.onlyIf { !rootProject.skipSigning }

task dist( type: Copy, dependsOn: install ) {

description "Unpack the binary distribution"

group = "distributions"

with binDistImage

into "$buildDir/dist"

}

def unpackedSrcDistDir = file( "build/unpacked-distributions/src/apache-zest-java-$version-src" )

def unpackedBinDistDir = file( "build/unpacked-distributions/bin/apache-zest-java-$version-bin" )

task unpackSrcDist( type: Copy ) {

description "Unpack the source distribution"

group = "distributions"

with srcDistImage

into 'build/unpacked-distributions/src'

}

task checkSrcDist( type: GradleBuild, dependsOn: unpackSrcDist ) {

description = "Check the source distribution by running the 'check' and 'assemble' tasks inside"

group = "distributions"

buildFile = "$unpackedSrcDistDir/build.gradle"

tasks = [ 'check', 'assemble' ]

}

task unpackBinDist( type: Copy, dependsOn: buildAll ) {

description "Unpack the binary distribution"

group = "distributions"

with binDistImage

into 'build/unpacked-distributions/bin'

}

task checkBinDist_rat( type: org.apache.rat.gradle.RatTask, dependsOn: unpackBinDist ) {

description "Check the binary distribution using Apache RAT"

group = "distributions"

inputDir = unpackedBinDistDir

reportDir = file( 'build/reports/rat-bin-dist' )

excludes = []

}

task checkBinDist_goOfflineGradle( type: GradleBuild, dependsOn: unpackBinDist ) {

description "Check the binary distribution Gradle go-offline helper"

group = "distributions"

def dependenciesDir = new File( unpackedBinDistDir, 'dependencies' )

doFirst { dependenciesDir.deleteDir() }

buildFile = "$unpackedBinDistDir/go-offline.gradle"

tasks = [ 'download' ]

doLast {

releaseApprovedProjects*.configurations.runtime.allDependencies.findAll({it.name}).each { dep ->

def jarArtifactId = dep.name instanceof String ? dep.name : dep.name.last()

def jarVersion = dep.version instanceof String ? dep.version : dep.version.last()

if( !jarArtifactId.startsWith( 'org.apache.zest' ) ) {

def jarName = "${jarArtifactId}-${jarVersion}.jar"

if( !new File( dependenciesDir, jarName ).exists() ) {

throw new GradleException( "Binary distribution go-offline.gradle failed! Missing: $jarName" );

}

}

}

}

}

task checkBinDist_goOfflineMaven( type: Exec, dependsOn: unpackBinDist ) {

description "Check the binary distribution Maven go-offline helper"

group = "distributions"

onlyIf {

def pathDirs = System.getenv( 'PATH' ).split( File.pathSeparator )

pathDirs.collect( { new File( it, 'mvn') } ).flatten().findAll( { it.isFile() } )

}

def dependenciesDir = new File( unpackedBinDistDir, 'dependencies' )

doFirst { dependenciesDir.deleteDir() }

workingDir unpackedBinDistDir

commandLine 'mvn', '-e', '-f', 'go-offline.pom', 'validate'

doLast {

releaseApprovedProjects*.configurations.runtime.allDependencies.findAll({it.name}).each { dep ->

def jarArtifactId = dep.name instanceof String ? dep.name : dep.name.last()

def jarVersion = dep.version instanceof String ? dep.version : dep.version.last()

if( !jarArtifactId.startsWith( 'org.apache.zest' ) ) {

def jarName = "${jarArtifactId}-${jarVersion}.jar"

if( !new File( dependenciesDir, jarName ).exists() ) {

throw new GradleException( "Binary distribution go-offline.pom failed! Missing: $jarName" );

}

}