build.gradle

import java.text.SimpleDateFormat
import java.util.jar.Attributes
import org.apache.tools.ant.taskdefs.condition.Os
import org.gradle.api.Task
import org.gradle.api.artifacts.repositories.WebdavResolver
import org.gradle.api.tasks.testing.ForkMode
import org.gradle.api.tasks.wrapper.Wrapper
import org.gradle.build.release.Svn
import org.gradle.build.release.Version
import org.gradle.build.samples.WrapperProjectCreator
import org.gradle.build.startscripts.StartScriptsGenerator
import org.apache.ivy.plugins.resolver.*
import org.gradle.build.docs.UserGuideTransformTask
import org.gradle.build.docs.ExtractSnippetsTask
import org.gradle.build.docs.SampleElementValidator

/**
 * For building Gradle you usually don't need to specify any properties. Only certain functionality of the Gradle requires
 * setting certain properties. Those properties can be set in the gradle.properties file in the the gradle user home. The
 * following properties can be set:
 *
 * Uploading distributions to Gradle's release and snapshot repository at codehaus: codehausUserName, codehausUserPassword
 * Uploading the userguide and the javadoc to Gradle's website: websiteFtpUserName, websiteFtpUserPassword
 * Using the build to create a new distribution and install it on the local machine: gradle_installPath
 * Creating a JDK-1.4 compatible distribution with retro-translator: gradle_retroLibsDir (This dir should contain rt.jar, jce.jar and jsse.jar from
 * a JDK 1.4).
 */

defaultTasks "clean", "dists"

usePlugin 'groovy'

svn = new Svn(project)

type = 'jar'

buildTime = new Date()
versionModifier = null

explodedDistDir = new File(distsDir, 'exploded')
explodedDistDocsDir = new File(explodedDistDir, 'docs')
explodedDistJavadocsDir = new File(explodedDistDocsDir, 'javadoc')
explodedDistGroovydocsDir = new File(explodedDistDocsDir, 'groovydoc')
explodedDistSamplesDir = new File(explodedDistDir, 'samples')
explodedDistLibDir = new File(explodedDistDir, 'lib')
samplesSrcDir = new File(srcRoot, 'samples')
userguideOutputDir = new File(samplesSrcDir, 'userguideOutput')

archivesBaseName = 'gradle'

allprojects {
    group = 'org.gradle'

    plugins.withType(JavaPlugin).whenPluginAdded {
        sourceCompatibility = 1.5
        targetCompatibility = 1.5
    }

    repositories {
        mavenCentral()
        add(new URLResolver()) {
            name = 'sf_gradleRepo'
            addArtifactPattern('http://gradle.sourceforge.net/gradleRepo/[organisation]/[module](/[branch])/[type]s/[artifact]-[revision](-[classifier])(.[ext])')
        }
    }

    version = new Version(svn, project, false)
}

def FIRST_LEVEL_JMOCK = ['org.hamcrest:hamcrest-core:1.1@jar', 'org.hamcrest:hamcrest-library:1.1@jar', 'org.jmock:jmock-junit4:2.4.0@jar']
subprojects {

    usePlugin 'groovy'
    usePlugin 'code-quality'

    dependencies {
        testCompile "junit:junit:4.5", FIRST_LEVEL_JMOCK
        testCompile module("org.jmock:jmock:2.4.0") {
            dependencies('org.jmock:jmock-legacy:2.4.0@jar', 'org.objenesis:objenesis:1.0', 'cglib:cglib-nodep:2.1_3')
            dependencies(FIRST_LEVEL_JMOCK as Object[])
        }
        // todo - these should not be here
        testCompile 'org.jmock:jmock-legacy:2.4.0@jar', 'org.objenesis:objenesis:1.0', 'cglib:cglib-nodep:2.1_3'
    }

    checkstyleConfigDir = "$rootDir/config/checkstyle"
    checkstyleConfigFileName = new File(checkstyleConfigDir, "checkstyle.xml")
    codeNarcConfigFileName = "$rootDir/config/codenarc.xml"
    [checkstyle, checkstyleTests].each { it.properties.checkstyleConfigDir = checkstyleConfigDir }

    groovydoc.destinationDir = explodedDistGroovydocsDir
}

allprojects {
    task ide << {task ->
        def libDir = task.project.file('lib')
        ant.delete(dir: libDir)
        copy {
            from task.project.configurations.testRuntime.copyRecursive(DependencySpecs.type(Type.EXTERNAL)).files
            into libDir
        }
    }
}

configurations {
    distLib {
        visible = false
    }
    ftpAntTask
    retrotranslatorAntTask
    userGuideStyleSheets
    userGuideTask
}

dependencies {
    distLib project(':gradle-wrapper'), project(':gradle-core'), project(':gradle-ui'), project(':gradle-open-api')

    // todo: Improve dependency handling for xUnit jars
    ftpAntTask module("org.apache.ant:ant-commons-net:1.7.0") {
        module("commons-net:commons-net:1.4.1") {
            dependencies("oro:oro:2.0.8@jar")
        }
    }

    retrotranslatorAntTask 'net.sf.retrotranslator:retrotranslator-runtime:1.2.7@jar', 'net.sf.retrotranslator:retrotranslator-transformer:1.2.7@jar',
            'backport-util-concurrent:backport-util-concurrent:3.1@jar'

    userGuideTask 'xalan:xalan:2.7.1', 'xerces:xercesImpl:2.9.1'
    userGuideTask module('xhtmlrenderer:xhtmlrenderer:R8rc1') {
        dependency 'itext:itext:2.0.8@jar'
    }
    userGuideTask 'xslthl:xslthl:2.0.1@jar'

    userGuideStyleSheets 'docbook:docbook-xsl:1.75.2@zip'

    groovy module("org.codehaus.groovy:groovy:1.6.4") {
        dependency("asm:asm-all:2.2.3@jar")
        dependency("antlr:antlr:2.7.7@jar")
        dependency("commons-cli:commons-cli:1.2@jar")
        module("org.apache.ant:ant:1.7.0") {
            dependencies("org.apache.ant:ant-junit:1.7.0@jar", "org.apache.ant:ant-launcher:1.7.0@jar")
        }
    }
}

clean.dependsOn subprojects*.clean

jar.enabled = false
task groovydoc(overwrite: true, dependsOn: subprojects*.groovydoc)
task check(overwrite: true, dependsOn: subprojects*.check)
task test(overwrite: true, dependsOn: subprojects*.test)

distributionUploadUrl = null
docsRemoteDir = ''
javadocRemoteDir = ''
groovydocRemoteDir = ''
gradle.taskGraph.whenReady {graph ->
    String prefix = ''
    if (graph.hasTask(':release')) {
        versionModifier = ''
        distributionUploadUrl = 'https://dav.codehaus.org/dist/gradle'
        prefix = version as String
    } else {
        versionModifier = new SimpleDateFormat('yyyyMMddHHmmssZ').format(buildTime)
        distributionUploadUrl = 'https://dav.codehaus.org/snapshots.dist/gradle'
        prefix = 'latest'
    }
    docsRemoteDir = prefix + '/docs'
    javadocRemoteDir = docsRemoteDir + '/javadoc'
    groovydocRemoteDir = docsRemoteDir + '/groovydoc'
    manifest.mainAttributes([
            (Attributes.Name.IMPLEMENTATION_TITLE.toString()): 'Gradle',
            (Attributes.Name.IMPLEMENTATION_VERSION.toString()): version.toString(),
    ])
}

task explodedDistBase(dependsOn: [libs, configurations.distLib.buildDependencies], description: 'Builds a minimal distribution image') << {
    [explodedDistDir, explodedDistLibDir]*.mkdirs()
    File explodedDistBinDir = mkdir(explodedDistDir, 'bin')

    logger.info('Generate lib dir')
    removeAnyExistingOldGradleLibs()
    copy {
        from configurations.distLib.files
        from jar.archivePath
        into explodedDistLibDir
    }
    logger.info('Generate start scripts')
    StartScriptsGenerator.generate(project('gradle-core').jar.archiveName, explodedDistBinDir, archivesBaseName)
    logger.info('Copy and generate top level files.')
    copy { from(new File(srcRoot, 'toplevel')).into explodedDistDir }
    // Set permissions (important for running integration tests against the exploded dist)
    ant.chmod(dir: "$explodedDistDir/bin", perm: "ugo+rx", includes: "**/*")
}

def removeAnyExistingOldGradleLibs() {
    ant.delete { fileset(dir: explodedDistLibDir, includes: "$archivesBaseName-*.jar") }
}

task javadoc(overwrite: true, type: Javadoc, dependsOn: subprojects*.compile) {
    srcDirs = subprojects.inject([]) {list, project -> list + project.source.main.java.srcDirs + project.groovySrcDirs}
    destinationDir = explodedDistJavadocsDir
    configuration = files(subprojects.collect { project-> [project.configurations.compile, project.source.main.classesDir] })
    // todo: include only the public packages
    options.subPackages 'org.gradle'
    exclude 'org.gradle.api.internal'
    // todo: make this true
    failOnError = false
    doFirst {
        title = "Gradle API $version"
        options.docTitle = title
    }
}

task docs(dependsOn: [javadoc, groovydoc, 'userguide', 'distDocs'])

task explodedDist(dependsOn: [explodedDistBase, docs, 'samples'], description: 'Builds a complete distribution image') << {
    logger.info('Copy binary sources.')
    File explodedDistSrcDir = mkdir(explodedDistDir, 'src')
    copy {
        into explodedDistSrcDir
        subprojects {
            from source.main.java.srcDirs, source.main.resources.srcDirs, groovySrcDirs
        }
    }
}

zipRootFolder = "$archivesBaseName-${-> version}"

distsRetroLibsFolder = new File(distsDir, 'retroLibs')

task retroTranslateLibs(dependsOn: explodedDist) << {
    distsRetroLibsFolder.mkdirs()
    ant {
        taskdef(name: "retrotranslator", classname: "net.sf.retrotranslator.transformer.RetrotranslatorTask",
                classpath: configurations.retrotranslatorAntTask.asPath)
        List libFiles = explodedDistLibDir.listFiles()
        File logbackCore = libFiles.find { it.name.startsWith('logback-core') }
        File logbackClassic = libFiles.find { it.name.startsWith('logback-classic') }
        File gradle = libFiles.find { it.name.startsWith('gradle-') && !it.name.startsWith('gradle-wrapper') }
        File gradleWrapper = libFiles.find { it.name.startsWith('gradle-wrapper')}
        List retroFiles = [logbackCore, logbackClassic, gradle, gradleWrapper]
        String libExcludes = retroFiles.join(',')
        retroFiles.each {File file ->
            retroExe(file) {
                fileset(dir: distsRetroLibsFolder)
                fileset(dir: explodedDistLibDir, excludes: libExcludes)
                fileset(dir: gradle_retroLibsDir)
            }
        }
    }
}
retroTranslateLibs {
    enabled = project.hasProperty('gradle_retroLibsDir')
}

void retroExe(File file, Closure fileSet) {
    ant {
        retrotranslator(target: "1.4", destjar: new File(distsRetroLibsFolder, file.name), smart: true, verify: false, failonwarning: false) {
            jarfileset(dir: explodedDistLibDir, includes: file.name)
            classpath() {
                fileset(dir: gradle_retroLibsDir)
                fileSet.delegate = delegate
                fileSet()
            }
        }
    }
}

Closure binFileSets = {task ->
    delegate = task
    zipFileSet(dir: explodedDistDir, prefix: zipRootFolder, fileMode: '775') {
        include 'bin/*'
        exclude 'bin/*.*'
    }
    zipFileSet(dir: explodedDistDir, prefix: zipRootFolder) {
        include 'bin/*.*'
    }
}

task allZip(type: Zip) {
    dependsOn explodedDist
    classifier = 'all'
}
allZip.doFirst {task ->
    task.configure {
        zipFileSet(dir: explodedDistDir, prefix: zipRootFolder) {
            exclude 'bin/*'
        }
        binFileSets(delegate)
    }
}

task binZip(type: Zip) {
    dependsOn explodedDist
    classifier = 'bin'
}
binZip.doFirst {task ->
    task.configure {
        zipFileSet(dir: explodedDistDir, prefix: zipRootFolder) {
            exclude 'bin/*'
            exclude 'src/'
            exclude 'samples/'
        }
        binFileSets(delegate)
    }
}

task srcZip(type: Zip) {
    dependsOn explodedDist
    classifier = 'src'
}
srcZip.doFirst {task ->
    task.configure {
        zipFileSet(dir: projectDir, prefix: zipRootFolder, fileMode: '775') {
            include 'gradlew'
        }
        zipFileSet(dir: projectDir, prefix: zipRootFolder) {
            include 'buildSrc/', 'wrapper/', 'lib/', 'src/', 'gradle.properties', 'build.gradle', 'gradlew.bat'
        }
    }
}

task jdk14AllZip(type: Zip) {
    dependsOn retroTranslateLibs, explodedDist
    classifier = 'all-jdk14'
    enabled = project.hasProperty('gradle_retroLibsDir')
}
jdk14AllZip.doFirst {Task task ->
    task.configure {
        zipFileSet(dir: explodedDistDir, prefix: zipRootFolder) {
            exclude 'bin/*'
            exclude 'lib/gradle*.jar'
            exclude 'lib/logback*.jar'
        }
        zipFileSet(dir: distsRetroLibsFolder, prefix: "$zipRootFolder/lib")
        configurations.retrotranslatorAntTask.each {File file ->
            zipFileSet(dir: file.parentFile, prefix: "$zipRootFolder/lib") {
                include file.name
            }
        }
        binFileSets(delegate)
    }
}

artifacts {
    tasks.findAll {task -> task.name.matches('.*Zip') }.each {
        dists it
    }
}

srcDocsDir = file('src/docs')
userguideDir = new File(buildDir, "$docsDir.name/userguide")
userguideSrcDir = new File(srcDocsDir, 'userguide')
userguideHtmlDir = new File(explodedDistDocsDir, 'userguide')
userguidePdfFile = new File(userguideHtmlDir, 'userguide.pdf')
userguideSingleHtmlFile = new File(userguideHtmlDir, 'userguide_single.html')
docbookSrc = new File(project.buildDir, 'docbook/src')
docbookDir = new File(project.buildDir, 'docbook/stylesheets')
snippetsDir = new File(project.buildDir, 'docbook/snippets')

task userguide(dependsOn: ['userguideHtml', 'userguideSingleHtml', 'userguidePdf'], description: 'Generates the userguide')

task samples(type: ExtractSnippetsTask) {
    sourceFiles = ant.fileset(dir: samplesSrcDir) {
        exclude(name: 'userguideOutput/**')
        exclude(name: 'userguide/tutorial/antChecksumFiles/**')
    }
    destDir = explodedDistSamplesDir
    snippetsDir = project.snippetsDir
}
samples << {
    copy {
        from samplesSrcDir
        into explodedDistSamplesDir
        include 'userguide/tutorial/antChecksumFiles/**'
    }
    WrapperProjectCreator.createProject(explodedDistSamplesDir, binZip.archivePath.parentFile,
            version.toString())
}

task userguideSrc(type: UserGuideTransformTask, dependsOn: samples) {
    sourceFile = new File(userguideSrcDir, 'userguide.xml')
    destFile = new File(docbookSrc, 'userguide.xml')
    snippetsDir = project.snippetsDir
    classpath = configurations.userGuideTask
    validator = new SampleElementValidator()
}
userguideSrc.doFirst {
    userguideSrc.javadocUrl = "http://www.gradle.org/${javadocRemoteDir}"
    userguideSrc.groovydocUrl = "http://www.gradle.org/${groovydocRemoteDir}"
}

task userguideStyleSheets << {
    ant.unzip(src: configurations.userGuideStyleSheets.singleFile, dest: docbookDir) {
        globmapper(from: 'docbook-xsl-1.75.2/*', to: '*')
    }
    copy {
        from new File(srcDocsDir, 'stylesheets')
        into docbookDir
        include '*.xsl'
    }
}

task userguideHtml(dependsOn: [userguideSrc, userguideStyleSheets]) << {
    ant.java(classname: 'org.apache.xalan.xslt.Process', failonerror: true, fork: true) {
        sysproperty(key: 'xslthl.config', value: new File("$docbookDir/highlighting/xslthl-config.xml").toURI())
        arg(value: '-in')
        arg(value: new File(docbookSrc, 'userguide.xml'))
        arg(value: '-xsl')
        arg(value: new File(docbookDir, 'userGuideHtml.xsl'))
        arg(line: "-param base.dir ${userguideHtmlDir}/")
        classpath {
            path(path: configurations.userGuideTask.asPath)
            path(location: new File(docbookDir, 'extensions/xalan27.jar'))
        }
    }
    copy {
        from userguideSrcDir
        into userguideHtmlDir
        include 'style.css'
        include 'images/*.png'
    }
}

task userguideSingleHtml(dependsOn: [userguideSrc, userguideStyleSheets]) << {
    userguideSingleHtmlFile.parentFile.mkdirs()
    
    ant.java(classname: 'org.apache.xalan.xslt.Process', failonerror: true, fork: true) {
        sysproperty(key: 'xslthl.config', value: new File("$docbookDir/highlighting/xslthl-config.xml").toURI())
        arg(value: '-in')
        arg(value: new File(docbookSrc, 'userguide.xml'))
        arg(value: '-out')
        arg(value: userguideSingleHtmlFile)
        arg(value: '-xsl')
        arg(value: new File(docbookDir, 'userGuideSingleHtml.xsl'))
        classpath {
            path(path: configurations.userGuideTask.asPath)
            path(location: new File(docbookDir, 'extensions/xalan27.jar'))
        }
    }
    copy {
        from userguideSrcDir
        into userguideSingleHtmlFile.parentFile
        include 'style.css'
        include 'images/*.png'
    }
}

task userguidePdf(dependsOn: [userguideSrc, userguideStyleSheets]) << {
    File pdfSourceHtml = new File(docbookSrc, 'userguidePdf.html')

    pdfSourceHtml.parentFile.mkdirs()
    userguidePdfFile.parentFile.mkdirs()

    println "transforming docbook -> html"

    ant.java(classname: 'org.apache.xalan.xslt.Process', failonerror: true, fork: true) {
        sysproperty(key: 'xslthl.config', value: new File("$docbookDir/highlighting/xslthl-config.xml").toURI())
        arg(value: '-in')
        arg(value: new File(docbookSrc, 'userguide.xml'))
        arg(value: '-out')
        arg(value: pdfSourceHtml)
        arg(value: '-xsl')
        arg(value: new File(docbookDir, 'userGuidePdf.xsl'))
        classpath {
            path(path: configurations.userGuideTask.asPath)
            path(location: new File(docbookDir, 'extensions/xalan27.jar'))
        }
    }

    println "copying resources"

    copy {
        from userguideSrcDir
        into pdfSourceHtml.parentFile
        include 'style.css'
        include 'print.css'
        include 'images/*.png'
    }

    println "transforming html -> pdf"

    def uris = configurations.userGuideTask.files.collect {it.toURI().toURL()}
    def classloader = new URLClassLoader(uris as URL[], getClass().classLoader)
    def renderer = classloader.loadClass('org.xhtmlrenderer.pdf.ITextRenderer').newInstance()
    renderer.setDocument(pdfSourceHtml)
    renderer.layout()

    userguidePdfFile.withOutputStream {
        renderer.createPDF(it)
    }

    println "done"
}

task uploadDocs(dependsOn: [userguide, javadoc, groovydoc]) << {
    ftp(action: 'mkdir', remotedir: docsRemoteDir)
    ftp(action: 'delete', remotedir: docsRemoteDir) {
        fileset() {
            include(name: '**/*')
        }
    }
    ftp(action: 'send', remotedir: docsRemoteDir) {
        fileset(dir: explodedDistDocsDir)
    }
}

task distDocs(type: UserGuideTransformTask, dependsOn: userguideStyleSheets) {
    standalone = true
    sourceFile = new File(userguideSrcDir, 'gettingStarted.xml')
    destFile = new File(docbookSrc, 'gettingStarted.xml')
    snippetsDir = project.snippetsDir
    classpath = configurations.userGuideTask
}
distDocs.doFirst {
    distDocs.javadocUrl = "http://www.gradle.org/${javadocRemoteDir}"
    distDocs.groovydocUrl = "http://www.gradle.org/${groovydocRemoteDir}"
}
distDocs << {
    explodedDistDir.mkdirs()

    copy {
        from userguideSrcDir
        into docbookDir
        include 'style.css'
    }
    ant.java(classname: 'org.apache.xalan.xslt.Process', failonerror: true, fork: true) {
        sysproperty(key: 'xslthl.config', value: new File("$docbookDir/highlighting/xslthl-config.xml").toURI())
        sysproperty(key: 'org.apache.xerces.xni.parser.XMLParserConfiguration', value: 'org.apache.xerces.parsers.XIncludeParserConfiguration')
        arg(value: '-in')
        arg(value: new File(docbookSrc , 'gettingStarted.xml'))
        arg(value: '-out')
        arg(value: new File(explodedDistDir, 'getting-started.html'))
        arg(value: '-xsl')
        arg(value: new File(docbookDir, 'standaloneHtml.xsl'))
        classpath {
            path(path: configurations.userGuideTask.asPath)
            path(location: new File(docbookDir, 'extensions/xalan27.jar'))
        }
    }
}

task websiteDocs(type: UserGuideTransformTask, dependsOn: userguideStyleSheets) {
    standalone = true
    sourceFile = new File(userguideSrcDir, 'gettingStarted.xml')
    destFile = new File(docbookSrc, 'gettingStarted.xml')
    snippetsDir = project.snippetsDir
    classpath = configurations.userGuideTask
}
websiteDocs.doFirst {
    websiteDocs.javadocUrl = "http://www.gradle.org/${javadocRemoteDir}"
    websiteDocs.groovydocUrl = "http://www.gradle.org/${groovydocRemoteDir}"
}
websiteDocs << {
    File websiteDocs = new File(buildDir, 'docs')
    websiteDocs.mkdirs()

    ant.java(classname: 'org.apache.xalan.xslt.Process', failonerror: true, fork: true) {
        arg(value: '-in')
        arg(value: new File(docbookSrc , 'gettingStarted.xml'))
        arg(value: '-out')
        arg(value: new File(websiteDocs, 'getting-started.html'))
        arg(value: '-xsl')
        arg(value: new File(docbookDir, 'docFragment.xsl'))
        classpath {
            path(path: configurations.userGuideTask.asPath)
            path(location: new File(docbookDir, 'extensions/xalan27.jar'))
        }
    }
}

// The integtests depend on dists because of the wrapper test, and userguideSrc because of the int test generated from
// the userguide source
integTestDistDir = new File(buildDir, 'integtest')
task integTest(type: Test, dependsOn: [explodedDist, binZip, userguideSrc, project('gradle-core').compileTest, project('gradle-core').processTestResources, project('gradle-core').processResources ]) {
    options.fork(forkMode: ForkMode.ONCE, jvmArgs: ["-ea"])
    options.systemProperties['integTest.gradleHomeDir'] = integTestDistDir.absolutePath
    options.systemProperties['integTest.srcDir'] = file('src').absolutePath
    options.systemProperties['integTest.userGuideInfoDir'] = docbookSrc.absolutePath

    include 'org/gradle/integtests/**/*IntegrationTest.*'
    exclude '**/Abstract*'
    
    testClassesDir = project('gradle-core').source.test.classesDir
    configuration = project('gradle-core').configurations.testRuntime
}
integTest.doFirst {
    ant {
        delete(dir: integTestDistDir)
        copy(todir: integTestDistDir) {
            fileset(dir: explodedDistDir )
        }
        chmod(dir: "$integTestDistDir/bin", perm: "ugo+rx", includes: "**/*")
    }
}

task testedDists(dependsOn: [dists, check, test, integTest])

task nightlyBuild(dependsOn: [clean, testedDists, uploadDocs])

task install(dependsOn: binZip, description: 'Installs the distribution into directory $gradle_installPath') << {
    ant.delete(dir: installDir)
    if (Os.isFamily(Os.FAMILY_WINDOWS)) {
        windowsInstall()
    } else {
        asternixInstall()
    }
    ant.move(file: "${installDir.parentFile}/$zipRootFolder", tofile: installDir)
}

gradle.taskGraph.whenReady { graph ->
    if (graph.hasTask(install)) {
        // Do this early to ensure that the properties we need have been set, and fail early
        installDir = file("$gradle_installPath")
        if (installDir.file) {
            throw new RuntimeException("Install directory $installDir does not look like a Gradle installation. Cannot delete it to install.")
        }
        if (installDir.directory) {
            File libDir = new File(installDir, "lib")
            if (!libDir.directory || !libDir.list().findAll { it.matches('gradle.*\\.jar')}) {
                throw new RuntimeException("Install directory $installDir does not look like a Gradle installation. Cannot delete it to install.")
            }
        }
    }
}

void windowsInstall() {
    ant.unzip(src: binZip.archivePath, dest: installDir.parentFile)
}

/**
 * We can't use the Ant unzip task, as this task does not preserve the *nix file system permissions of the Gradle zip.
 */
void asternixInstall() {
    ant.exec(executable: "unzip") {
        arg(value: '-q')
        arg(value: '-d')
        arg(value: installDir.parentFile)
        arg(value: "${binZip.archivePath}")
    }
}

uploadDists {
    dependsOn testedDists
}.doFirst {
    it.repositories.add(new WebdavResolver()) {
        name = 'gradleReleases'
        user = codehausUserName
        userPassword = codehausUserPassword
        addArtifactPattern("$distributionUploadUrl/[artifact]-[revision](-[classifier]).[ext]" as String)
    }
}
gradle.taskGraph.whenReady {graph ->
    if (graph.hasTask(uploadDists)) {
        // check properties defined and fail early
        codehausUserName
        codehausUserPassword
    }
}

task developerBuild(dependsOn: [clean, testedDists])
task ciBuild(dependsOn: [clean, testedDists])

task release(dependsOn: [uploadDists, uploadDocs]) << {
    svn.release()
}

task wrapper(type: Wrapper, dependsOn: binZip)
wrapper.doFirst {task ->
    task.configure {
        gradleVersion = version
        jarPath = 'wrapper'
    }
}

task rebuildWrapper(dependsOn: [clean, wrapper])

void ftp(Map args, Closure antFileset = {}) {
    ant {
        taskdef(name: 'ftp',
                classname: 'org.apache.tools.ant.taskdefs.optional.net.FTP',
                classpath: configurations.ftpAntTask.asPath)
        Map ftpArgs = args + [
                server: 'ftp.gradle.org',
                userid: websiteFtpUserName,
                password: websiteFtpUserPassword
        ]
        delegate.ftp(ftpArgs) {
            antFileset.delegate = delegate
            antFileset()
        }
    }
}