spring-security/build.gradle

apply plugin: 'base'

buildscript {
    repositories {
        mavenRepo urls: 'http://gradle.artifactoryonline.com/gradle/plugins'
    }
    dependencies {
        classpath "org.gradle.plugins:gradle-idea-plugin:0.3"
    }
}

allprojects {
    version = '3.1.0.CI-SNAPSHOT'
    releaseBuild = version.endsWith('RELEASE')
    snapshotBuild = version.endsWith('SNAPSHOT')

    group = 'org.springframework.security'

    repositories {
        mavenRepo name:'Local', urls: "file://" + System.properties['user.home'] + "/.m2/repository"
        mavenCentral()
        mavenRepo name: 'SpringSource Milestone Repo', urls: 'http://repository.springsource.com/maven/bundles/milestone'
        mavenRepo name: 'SpringSource Maven Snapshot Repo', urls: 'http://maven.springframework.org/snapshot/'
        mavenRepo name: 'SpringSource Enterprise Release', urls: 'http://repository.springsource.com/maven/bundles/release'
        mavenRepo name: 'SpringSource Enterprise External', urls: 'http://repository.springsource.com/maven/bundles/external'
        mavenRepo(name: 'Spock Snapshots', urls: 'http://m2repo.spockframework.org/snapshots')
    }
}

allprojects {
    apply plugin: 'idea'
    ideaModule {
        downloadJavadoc=false
        excludeDirs.add(buildDir)
    }
    def config = configurations.findByName('testRuntime')
    if (!config) {
        return
    }
    ideaModule {
        gradleCacheVariable = 'GRADLE_CACHE'
    }
}

ideaModule {
    excludeDirs.add(file('.gradle'))
    excludeDirs.add(file('buildSrc/build'))
    excludeDirs.add(file('buildSrc/.gradle'))
}

ideaProject {
    wildcards += ['?*.gradle']
    javaVersion = '1.6'

    withXml { node ->
        node.component.find { it.@name == 'VcsDirectoryMappings' }.mapping.@vcs = 'Git'
    }
}
/*
ideaWorkspace {
    withXml { node ->
        Node servers = node.component.find{ it.@name == 'TaskManager' }.servers[0]
        def bldr = new NodeBuilder()
        servers.append(
            bldr.JIRA(shared: false, url: 'https://jira.springsource.org') {
                if (project.hasProperty('jiraUser')) {
                    password project.property('jiraPassword')
                    username project.property('jiraUser')
                }
            })
    }
}
*/
configure(javaProjects) {
    apply from: "$rootDir/gradle/javaprojects.gradle"
}

configure(coreModuleProjects) {
    apply from: "$rootDir/gradle/bundlor.gradle"
    apply from: "$rootDir/gradle/maven.gradle"
    // Gives better names in structure101 jar diagram
    sourceSets.main.classesDir = new File(buildDir, "classes/" + project.name.substring("spring-security".length() + 1))
}

configure (aspectjProjects) {
    apply from: "$rootDir/gradle/aspectj.gradle"
}

configurations {
    antlibs
}

dependencies {
    antlibs "org.springframework.build:org.springframework.build.aws.ant:3.0.3.RELEASE",
            "net.java.dev.jets3t:jets3t:0.6.1"
}

task apidocs(type: Javadoc) {
    destinationDir = new File(buildDir, 'apidocs')
    title = "Spring Security $version API"
    optionsFile = file("$buildDir/tmp/javadoc.options")

    source coreModuleProjects.collect {project ->
        project.sourceSets.main.allJava
    }

    classpath = files(coreModuleProjects.collect {project ->
        project.sourceSets.main.compileClasspath
    })
}

task docSiteLogin(type: Login) {
    if (project.hasProperty('sshHost')) {
        host = project.property('sshHost')
    }
}

// Define remoteSiteDir and sshHost in gradle.properties
def remoteDocsDir = null

if (hasProperty('remoteSiteDir')) {
    remoteDocsDir="$remoteSiteDir/docs/3.1.x"
}

task uploadApidocs(type: TarUpload) {
    dependsOn apidocs
    classifier = 'apidocs'
    remoteDir = remoteDocsDir
    login = docSiteLogin

    into('apidocs') {
        from apidocs.destinationDir
    }
}

def docsDir = new File(project(':manual').buildDir, 'docs')

task uploadDoc(type: TarUpload) {
    dependsOn ':manual:doc'
    classifier = 'doc'
    remoteDir = remoteDocsDir
    login = docSiteLogin

    into('reference') {
        from docsDir
    }
}

task uploadFaq(type: TarUpload) {
    dependsOn ':faq:docbookHtmlSingle'
    classifier = 'faq'
    if (project.hasProperty('remoteSiteDir')) {
        remoteDir = project.property('remoteSiteDir')
    }
    login = docSiteLogin

    def faqDir = new File(project(':faq').buildDir, 'docs')

    into('faq') {
        from faqDir
    }
}

task dist(type: Zip) {
    def zipRootDir = "${project.name}-$version"
    into(zipRootDir) {
        into('docs/apidocs') {
            from apidocs.destinationDir
        }
        into('docs/reference') {
            from docsDir
        }
        into('dist') {
            from coreModuleProjects.collect {project -> project.libsDir }
            from project(':spring-security-samples-tutorial').libsDir
            from project(':spring-security-samples-contacts').libsDir
        }
    }
}

dist {
    dependsOn apidocs, ':manual:doc', subprojects.collect { "$it.path:assemble" }
    doLast {
        ant.checksum(file: archivePath, algorithm: 'SHA1', fileext: '.sha1')
    }
}

task uploadDist(type: UploadDist) {
    archiveFile = dist.archivePath
    shaFile = "${dist.archivePath}.sha1" as File
    archiveName = dist.archiveName
    classpath = configurations.antlibs
}

def getJavaProjects() {
    subprojects.findAll {project -> project.name != 'faq' && project.name != 'manual' }
}

def getSampleProjects() {
    subprojects.findAll {project -> project.name.startsWith('spring-security-samples') }
}

def getItestProjects() {
    subprojects.findAll {project -> project.name.startsWith('itest') }
}

def getCoreModuleProjects() {
    javaProjects - sampleProjects - itestProjects
}

def getAspectjProjects() {
    [project(':spring-security-aspects'), project(':spring-security-samples-aspectj')]
}

def getReleaseProjects() {
    coreModuleProjects +project(':spring-security-aspects')
}

class UploadDist extends DefaultTask {
    @InputFile
    File shaFile

    @InputFile
    File archiveFile

    @Input
    String archiveName

    @InputFiles
    def classpath

    @TaskAction
    def upload() {
        def accessKey = project.s3AccessKey
        def secretKey = project.s3SecretAccessKey
        def version = project.version

        project.ant {
            taskdef(resource: 'org/springframework/build/aws/ant/antlib.xml', classpath: classpath.asPath)
            s3(accessKey: accessKey, secretKey: secretKey) {
                upload(bucketName: 'dist.springframework.org', file: archiveFile,
                        toFile: releaseType() + "/SEC/${archiveName}", publicRead: 'true') {
                    metadata(name: 'project.name', value: 'Spring Security')
                    metadata(name: 'release.type', value: releaseType())
                    metadata(name: 'bundle.version', value: version)
                    metadata(name: 'package.file.name', value: archiveName)
                }
                upload(bucketName: 'dist.springframework.org', file: shaFile,
                        toFile: releaseType() + "/SEC/${archiveName}.sha1", publicRead: 'true')
            }
        }
    }

    def releaseType() {
        if (project.releaseBuild) {
            'release'
        } else if (project.snapshotBuild) {
            'snapshot'
        } else {
            'milestone'
        }
    }
}