build.gradle

description = "Package for ueditor and aliyun's OSS $version, Create By Xie Xianbin."

defaultTasks "clean", "build"

ext {
    publishSnapshots = Boolean.getBoolean("publishSnapshots")
    publishReleases = Boolean.getBoolean("publishReleases")
    sonatypeUsername = System.getProperty("sonatypeUsername")
    sonatypePassword = System.getProperty("sonatypePassword")
}

def isArtifactSigningRequired = {
    if (publishReleases && sonatypeUsername != null && sonatypePassword != null) {
        return true
    }
    return false
}

apply from: rootProject.file("gradle/overrides.gradle")
apply from: rootProject.file("gradle/dependencies.gradle")
apply plugin: "com.gradle.build-scan"

buildScan {
    licenseAgreementUrl = "https://gradle.com/terms-of-service"
    licenseAgree = "yes"
}

buildscript {
    repositories {
        mavenLocal()
        mavenCentral()
        jcenter()

        maven { url "https://plugins.gradle.org/m2/" }
        maven { url "http://repo.spring.io/plugins-release" }
    }

    dependencies {
        classpath "org.springframework.boot:spring-boot-gradle-plugin:$springBootVersion"
        classpath "com.netflix.nebula:gradle-lint-plugin:6.1.1"
        classpath "org.standardout:gradle-versioneye-plugin:1.4.0"
        classpath "org.springframework.build.gradle:propdeps-plugin:0.0.7"
        classpath "com.gradle:build-scan-plugin:1.0"
    }
}

allprojects {
    apply plugin: "idea"
    apply plugin: "eclipse"
    apply plugin: "maven"
    apply plugin: "signing"
    apply plugin: "org.standardout.versioneye"
    apply plugin: "nebula.lint"

    apply from: rootProject.file("gradle/maven.gradle")
    
    gradleLint.rules = ["dependency-parentheses", "dependency-tuple"]

    signing {
        required = isArtifactSigningRequired
        sign configurations.archives
    }

    idea {
        module {
            downloadSources = false
            downloadJavadoc = false
        }
    }

    signArchives.enabled = rootProject.publishReleases || rootProject.publishSnapshots

    /*
    Do NOT publish test dependencies into the final POM.
    */
    conf2ScopeMappings.mappings.remove(configurations.findByName("testCompile"))
    conf2ScopeMappings.mappings.remove(configurations.findByName("testRuntime"))
}

subprojects {
    task allDependenciesInsight(type: DependencyInsightReportTask, description: "Produce insight information for all dependencies") {
        doLast {}
    }
    task allDependencies(type: DependencyReportTask, description: "Display a graph of all project dependencies") {
        doLast {}
    }

    apply plugin: "java"
    apply plugin: "checkstyle"
    apply plugin: "findbugs"
    apply plugin: "project-report"
    apply plugin: "propdeps"
    apply plugin: "propdeps-maven"
    apply plugin: "propdeps-idea"
    apply plugin: "propdeps-eclipse"


    apply from: rootProject.file("gradle/tasks.gradle")

    ext.libraries = rootProject.ext.libraries;

    repositories {
        mavenLocal()
        /*mavenCentral()
        jcenter()*/

        maven { url "http://maven.aliyun.com/nexus/content/groups/public" }
        maven { url "http://maven.aliyun.com/nexus/content/repositories/public" }
        maven { url "http://maven.aliyun.com/nexus/content/repositories/releases" }
        maven { url "http://maven.aliyun.com/nexus/content/repositories/snapshots" }
        maven { url "http://maven.aliyun.com/nexus/content/repositories/jcenter" }
        maven { url "https://oss.sonatype.org/content/repositories/snapshots" }
        maven { url "https://oss.sonatype.org/content/repositories/releases" }
        maven { url "http://repo.maven.apache.org/maven2" }
        maven { url "https://repo.spring.io/milestone" }
        maven { url "https://repo.spring.io/snapshot" }
        maven { url "https://repo.spring.io/libs-snapshot" }
    }

    test {
        enabled = !Boolean.getBoolean("skipTests")
        useJUnit()
        scanForTestClasses = false

        ignoreFailures = Boolean.getBoolean("ignoreTestFailures")
        include "**/*Tests.*"
        exclude "**/*Abstract*.*"
        classpath = it.classpath + files("${projectDir}/src/main/resources") +
                files("${projectDir}/src/test/resources")
        testLogging {
            events = ["FAILED", "STANDARD_OUT"]
            exceptionFormat = "full"
            showStandardStreams = Boolean.getBoolean("showStandardStreams")
            showExceptions = true
            showCauses = true
        }
    }

    configurations {
        tests
    }

    configurations.all {
        resolutionStrategy {
            if (!Boolean.getBoolean("skipVersionConflict")) {
                failOnVersionConflict()
            }
            cacheDynamicVersionsFor 5, 'days'
            cacheChangingModulesFor 5, 'days'
        }
        exclude(group: "ch.qos.logback", module: "logback-core")
        exclude(group: "ch.qos.logback", module: "logback-classic")
        exclude(group: "cglib", module: "cglib")
        exclude(group: "cglib", module: "cglib-full")
    }

    artifacts {
        tests testJar

        archives sourcesJar
        archives javadocJar
        archives resourcesJar
        archives testJar
    }


    sourceSets {
        test.resources.srcDirs = ["${projectDir}/src/test/resources", "${projectDir}/src/test/java"]
    }

    ext.buildDate = null
    ext.buildJarFile = new File(project.buildDir, "libs/${project.name}-${project.version}.jar")
    
    compileJava.options.fork = true

    if (Boolean.getBoolean("enableIncremental")) {
        compileJava.options.incremental = true
    }

    def currentTime = java.time.ZonedDateTime.now()
    compileJava.doLast {
        buildDate = currentTime
        jar.manifest {
            attributes("Implementation-Date": project.buildDate)
        }
    }

    tasks.jar.onlyIf {
        project.buildDate != null || !project.buildJarFile.exists()
    }

    jar {
        manifest {
            attributes("Implementation-Title": project.name,
                       "Implementation-Vendor": project.group,
                       "Created-By": project.group,
                       "Implementation-Version": project.version)
        }
    }

    checkstyle {
        configFile new File(rootDir, "checkstyle-rules.xml")
        configProperties = ["checkstyle.suppressions.file": new File(rootDir, "checkstyle-suppressions.xml")]
        ignoreFailures true
        showViolations false
        toolVersion "${checkstyleVersion}"
    }

    checkstyleTest {
        enabled = !Boolean.getBoolean("skipCheckstyle")
    }

    checkstyleMain {
        enabled = !Boolean.getBoolean("skipCheckstyle")
    }

    versioneye {
        includePlugins = false
        includeSubProjects = true
    }
    
    findbugs {
        toolVersion = "${findbugsVersion}"
        sourceSets = [sourceSets.main]
        ignoreFailures = true
        reportsDir = file("$project.buildDir/findbugsReports")
        effort = "max"
        reportLevel = "low"
        includeFilter = file("$rootProject.projectDir/findbugs-rules.xml")
    }

    findbugsMain {
        enabled = !Boolean.getBoolean("skipFindbugs")
        reports {
            xml.enabled = false
            html.enabled = true
        }
    }

    findbugsTest {
        enabled = !Boolean.getBoolean("skipFindbugs")
    }

    dependencies {
        compile libraries.log4j
        compile libraries.commons

        compileOnly libraries.javax

        if (Boolean.getBoolean("genConfigMetadata")) {
            optional libraries.springbootconfigmetadata
        }

        if (!Boolean.getBoolean("skipFindbugs")) {
            findbugs libraries.findbugs
            findbugs configurations.findbugsPlugins.dependencies
            findbugsPlugins libraries.findbugscontrib
            findbugsPlugins libraries.findbugssec
        }

        //testCompile libraries.tests
        runtime libraries.javaximpl
    }
    
    if (Boolean.getBoolean("genConfigMetadata")) {
        compileJava.dependsOn(processResources)
    }
}

task wrapper(type: Wrapper, description: "Gradle wrapper") {
    gradleVersion = project.gradleVersion
}

task javadoc(type: Javadoc, description: "Aggregate all Javadocs into a single directory") {
    source subprojects.collect { project -> project.sourceSets.main.allJava }
    destinationDir = new File(buildDir, "javadoc")
    classpath = files(subprojects.collect { project -> project.sourceSets.main.compileClasspath })
}

javadoc {
    options{
        encoding "UTF-8"
        charSet "UTF-8"
        author true
        version true
    }
}

task aggregateJavadocsIntoJar(type: Jar, dependsOn: javadoc,
        description: "Aggregate all Javadocs into a single directory") {
    classifier = "javadoc"
    from javadoc
}

task rootSourcesJar(type: Jar, description: "Build JAR for the root CAS module") {
    baseName = "${project.archivesBaseName}"
    from rootProject.file("src")
}

artifacts {
    archives aggregateJavadocsIntoJar
    archives rootSourcesJar
}