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 'io.spring.gradle:spring-io-plugin:0.0.4.RELEASE'
        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')
    }
}

// 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'

    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']

    test.systemProperty("java.awt.headless", "true")

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

    dependencies {
        testCompile ("org.hamcrest:hamcrest-library:$hamcrestVersion")
        testCompile ("junit:junit:$junitVersion")
        testCompile ("org.mockito:mockito-core:$mockitoVersion")
        testCompile ("org.springframework:spring-test:$springVersion")
        testRuntime ("com.jayway.jsonpath:json-path:$jsonPathVersion")
    }

    // 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
    }
}

ext.javadocLinks = [
    "https://docs.jboss.org/jbossas/javadoc/4.0.5/connector"
] as String[]

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 {
        options.memberLevel = org.gradle.external.javadoc.JavadocMemberLevel.PROTECTED
        options.author = true
        options.header = project.name
        //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
    }
}

project('spring-social-linkedin') {
    description = 'LinkedIn 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")
      testCompile ("org.springframework.security:spring-security-crypto:$springSecurityVersion")
      testCompile ("org.apache.httpcomponents:httpclient:4.5.3", optional)
    }
}

project("spring-social-linkedin-autoconfigure") {
    description = "Spring Social LinkedIn Auto-Configuration"
    dependencies {
      compile project(":spring-social-linkedin")
      compile("org.springframework.social:spring-social-autoconfigure:$springSocialVersion")
      compile("org.springframework.boot:spring-boot-autoconfigure:$springBootVersion")
    }
}

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

    apply plugin: 'docbook-reference'

    reference {
        ext.sourceDir = file('src/reference/docbook')
    }

    // 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)

        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')