build.gradle

buildscript {
    repositories {
        maven { url 'https://repo.spring.io/plugins-release' }
    }
    dependencies {
        classpath 'org.springframework.build.gradle:docbook-reference-plugin:0.2.8'
        classpath 'me.champeau.gradle:gradle-javadoc-hotfix-plugin:0.1'
        classpath('org.asciidoctor:asciidoctor-gradle-plugin:0.7.0')
        classpath('org.asciidoctor:asciidoctor-java-integration:0.1.4.preview.1')
        classpath 'io.spring.gradle:spring-io-plugin:0.0.6.RELEASE'
    }
}

// Set up different subproject lists for individual configuration
ext.javaProjects = subprojects.findAll { project -> project.name != 'docs' && project.name != 'manual' }
ext.docProjects = subprojects.findAll { project -> project.name == 'docs' || project.name == 'manual' }
ext.coreModuleProjects = javaProjects

configure(allprojects - docProjects) {
    apply plugin: 'java'
    apply plugin: 'eclipse'
    apply plugin: 'idea'
    apply plugin: 'javadocHotfix'
    apply plugin: "maven"

    group = 'org.springframework.social'

    compileJava {
        sourceCompatibility=1.8
        targetCompatibility=1.8
    }
    compileTestJava {
        sourceCompatibility=1.8
        targetCompatibility=1.8
    }

    [compileJava, compileTestJava]*.options*.compilerArgs = ['-Xlint:none']

    sourceSets.test.resources.srcDirs = ['src/test/resources', 'src/test/java']

    tasks.withType(Test).all {
        systemProperty("java.awt.headless", "true")
    }

    repositories {
        maven { url "https://repo.spring.io/libs-snapshot" }
        maven { url "https://repo.spring.io/libs-milestone" }
        mavenLocal()
    }

    dependencies {
        testCompile "org.hamcrest:hamcrest-library:$hamcrestVersion"
        testCompile "junit:junit:$junitVersion"
        testCompile "org.mockito:mockito-core:$mockitoVersion"
        testCompile "org.springframework:spring-test:$springVersion"
    }

    ext.javadocLinks = [
        "https://docs.oracle.com/javase/7/docs/api/",
        "https://docs.oracle.com/javaee/7/api/",
        "https://docs.spring.io/spring/docs/${springVersion}/javadoc-api/",
        "https://docs.jboss.org/jbossas/javadoc/4.0.5/connector/"
    ] as String[]

    // servlet-api (2.5) and tomcat-servlet-api (3.0) classpath entries should not be
    // exported to dependent projects in Eclipse to avoid false compilation errors due
    // to changing APIs across these versions
    eclipse.classpath.file.whenMerged { classpath ->
        classpath.entries.findAll { entry -> entry.path.contains('servlet-api') }*.exported = false

        // When the root project's name is the same as a dependency project's name, the name ends
        // up being duplicated in the classpath entry. For example a dependency on "spring-social-facebook"
        // would have a path of "/spring-social-facebook-spring-social-facebook".
        // The following lines set the path properly in that case.
        classpath.entries.findAll { entry ->
            if (entry.path.equals("/" + rootProject.name + "-" + rootProject.name)) {
                entry.path = "/" + rootProject.name;
            }
        }
    }
}

configure(subprojects - docProjects) { subproject ->
    apply from: "${rootProject.projectDir}/publish-maven.gradle"

    if (project.hasProperty('platformVersion')) {
        apply plugin: 'spring-io'

        repositories {
            maven { url "https://repo.spring.io/libs-snapshot" }
        }

        dependencyManagement {
            springIoTestRuntime {
                imports {
                    mavenBom "io.spring.platform:platform-bom:${platformVersion}"
                }
            }
        }
    }

    jar {
        manifest.attributes['Implementation-Title'] = subproject.name
        manifest.attributes['Implementation-Version'] = subproject.version

        from("${rootProject.projectDir}/src/dist") {
            include "license.txt"
            include "notice.txt"
            into "META-INF"
            expand(copyright: new Date().format('yyyy'), version: project.version)
        }
    }

    javadoc {
        description = "Generates project-level javadoc for use in -javadoc jar"

        options.memberLevel = org.gradle.external.javadoc.JavadocMemberLevel.PROTECTED
        options.author = true
        options.header = project.name
        options.links(project.ext.javadocLinks)
        if (JavaVersion.current().isJava8Compatible()) {
            options.addStringOption('Xdoclint:none', '-quiet')
        }
        //options.overview = "${projectDir}/src/main/java/overview.html"
    }

    task sourcesJar(type: Jar, dependsOn:classes) {
        classifier = 'sources'
        from sourceSets.main.allJava
    }

    task javadocJar(type: Jar) {
        classifier = 'javadoc'
        from javadoc
    }

    artifacts {
        archives sourcesJar
        archives javadocJar
    }

    configurations {
        springReleaseTestRuntime.extendsFrom testRuntime
        springSnapshotTestRuntime.extendsFrom testRuntime
    }

    // Test against latest Spring Framework release
    configurations.springReleaseTestRuntime {
        resolutionStrategy.eachDependency { DependencyResolveDetails details ->
            if (details.requested.group == 'org.springframework') {
                details.useVersion springReleaseVersion
            }
        }
    }

    // Test against latest Spring Framework snapshot
    configurations.springSnapshotTestRuntime {
        resolutionStrategy.eachDependency { DependencyResolveDetails details ->
            if (details.requested.group == 'org.springframework') {
                details.useVersion springSnapshotVersion
            }
        }
    }

    task springReleaseTest(type: Test) {
        classpath = sourceSets.test.output + sourceSets.main.output + configurations.springReleaseTestRuntime
        getReports().getJunitXml().setDestination(file("$buildDir/spring-release-test-results/"))
        getReports().getHtml().setDestination(file("$buildDir/reports/spring-release-tests/"))
    }
    check.dependsOn springReleaseTest

    task springSnapshotTest(type: Test) {
        classpath = sourceSets.test.output + sourceSets.main.output + configurations.springSnapshotTestRuntime
        getReports().getJunitXml().setDestination(file("$buildDir/spring-snapshot-test-results/"))
        getReports().getHtml().setDestination(file("$buildDir/reports/spring-snapshot-tests/"))
    }
    check.dependsOn springSnapshotTest

    configure([test, springReleaseTest, springSnapshotTest]) {
        systemProperties['springVersion'] = springVersion
    }
}


project('spring-social-facebook') {
    description = 'Facebook API'
    dependencies {
        compile ("org.springframework.social:spring-social-core:$springSocialVersion")
        compile ("org.springframework.social:spring-social-config:$springSocialVersion")
        compile ("org.springframework.social:spring-social-security:$springSocialVersion", optional)
        compile ("com.fasterxml.jackson.core:jackson-core:$jacksonVersion")
        compile ("com.fasterxml.jackson.core:jackson-databind:$jacksonVersion")
        compile ("com.fasterxml.jackson.core:jackson-annotations:$jacksonVersion")
        compile ("javax.servlet:javax.servlet-api:$servletApiVersion", provided)
        testCompile ("org.springframework:spring-test:$springVersion")
    }
}

project('spring-social-facebook-web') {
    description = 'Facebook Web'
    dependencies {
        compile ("org.springframework:spring-web:$springVersion")
        compile ("org.springframework:spring-webmvc:$springVersion")
        compile ("org.springframework.social:spring-social-core:$springSocialVersion", optional)
        compile project(':spring-social-facebook', optional)
        compile ("com.fasterxml.jackson.core:jackson-core:$jacksonVersion", optional)
        compile ("com.fasterxml.jackson.core:jackson-databind:$jacksonVersion", optional)
        compile ("com.fasterxml.jackson.core:jackson-annotations:$jacksonVersion", optional)
        compile ("javax.servlet:javax.servlet-api:$servletApiVersion", provided)
        compile ("javax.servlet.jsp:javax.servlet.jsp-api:$jspApiVersion", provided)
        testCompile ("org.springframework:spring-test:$springVersion")
    }
}

project("spring-social-facebook-autoconfigure") {
    description = "Spring Social Facebook Auto-Configuration"
    dependencies {
      compile project(":spring-social-facebook")
      compile("org.springframework.social:spring-social-autoconfigure:$springSocialVersion")
      compile("org.springframework.boot:spring-boot-autoconfigure:$springBootVersion")
      testCompile("org.springframework.boot:spring-boot-test:$springBootVersion")
      testCompile("org.assertj:assertj-core:1.0.0")
    }
}

configure(rootProject) {
    description = 'Spring Social Facebook'

    // don't publish the default jar for the root project
    configurations.archives.artifacts.clear()

    dependencies { // for integration tests
    }

    task api(type: Javadoc) {
        group = "Documentation"
        description = "Generates aggregated Javadoc API documentation."
        title = "${rootProject.description} ${version} API"
        options.memberLevel = org.gradle.external.javadoc.JavadocMemberLevel.PROTECTED
        options.author = true
        options.header = rootProject.description
        options.overview = "src/api/overview.html"
        options.links(project.ext.javadocLinks)
        if (JavaVersion.current().isJava8Compatible()) {
            options.addStringOption('Xdoclint:none', '-quiet')
        }

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

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

        maxMemory = "1024m"
        destinationDir = new File(buildDir, "api")
    }

    // Task for creating the distro zip

    task dist(type: Zip) {
        dependsOn subprojects*.tasks*.matching { task -> task.name == 'assemble' || task.name.endsWith('Zip') || task.name.endsWith('generatePom') }
        classifier = 'dist'

        evaluationDependsOn(':docs')
        evaluationDependsOn(':docs:manual')

        def zipRootDir = "${project.name}-$version"
        into(zipRootDir) {
            from(rootDir) {
                include '*.txt'
            }
            into('docs') {
                with(project(':docs').apiSpec)
                with(project(':docs:manual').spec)
            }
            into('dist') {
                from coreModuleProjects.collect {project -> project.libsDir }
            }
        }
    }

    artifacts {
        archives dist
        archives project(':docs').docsZip
        archives project(':docs').schemaZip
    }

    task wrapper(type: Wrapper) {
        description = 'Generates gradlew[.bat] scripts'
        gradleVersion = '3.0'
    }

}

configure(docProjects) {
    tasks.findByPath("artifactoryPublish")?.enabled = false
}

task updateRootDocs << {
    copy {
        from 'src/dist'
        into "${rootProject.projectDir}"
        include 'notice.txt'
        expand(copyright: new Date().format('yyyy'), version: project.version)
        rename { filename -> 'NOTICE' }
    }

    copy {
        from 'src/dist'
        into "${rootProject.projectDir}"
        include 'license.txt'
        rename { filename -> 'LICENSE' }
    }
}

build.dependsOn('updateRootDocs')