build.gradle

/*
 * Copyright (C) 2011 JFrog Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


buildscript {
    repositories {
        jcenter()
        //mavenLocal()
        dependencies { classpath 'org.jfrog.buildinfo:build-info-extractor-gradle:3.0.1' }
    }
    configurations.classpath {
        resolutionStrategy {
            failOnVersionConflict()
            cacheDynamicVersionsFor 0, 'seconds'
            cacheChangingModulesFor 0, 'seconds'
			force "commons-codec:commons-codec:1.8"
        }
    }
}


import org.jfrog.build.Version
import org.apache.tools.ant.filters.ReplaceTokens

// Root project version should not be used
project.version = '2'
project.ext.baseProjectNames = ['build-info-api', 'build-info-client', 'build-info-extractor', 'build-info-vcs']

defaultTasks 'clean', 'build', 'install'

allprojects {
    apply plugin: 'idea'
    apply plugin: 'com.jfrog.artifactory-upload'

    group = 'org.jfrog.buildinfo'

    repositories {
        maven { url "https://oss.jfrog.org/jfrog-dependencies" }
        jcenter()
    }
}

artifactory {
    contextUrl = 'https://localhost:8080/artifactory'
    //contextUrl = 'https://oss.jfrog.org'
    publish {
        defaults {
            publishConfigs('archives', 'published')
            properties = ['build.status': "$it.project.status".toString(), 'bintray.repo': 'jfrog/jfrog-jars']
        }
    }
}

artifactoryPublish.skip = true

def baseProjects() {
    subprojects.findAll { p -> baseProjectNames.contains(p.name) }
}

def extractorProjects() {
    subprojects.findAll { p -> !baseProjectNames.contains(p.name) }
}

subprojects {
    apply plugin: 'maven'
    apply plugin: 'java'

    repositories {
        jcenter()
        maven { url 'http://oss.jfrog.org/artifactory/oss-snapshot-local/' }
        mavenLocal()
    }

    sourceCompatibility = 1.6
    targetCompatibility = 1.6
    ext.buildInfoVersion = new Version(rootProject, baseProjectNames)

    configurations {
        published
    }

    dependencies {
        compile group: 'commons-lang', name: 'commons-lang', version: '2.4'
        compile group: 'commons-logging', name: 'commons-logging', version: '1.1.1'
        compile group: 'commons-io', name: 'commons-io', version: '2.0.1'
        testCompile group: 'org.testng', name: 'testng', version: '5.12.1'
    }

    // From the install task of the maven plugin (an upload task), take the RepositoryHandler (repositories) and for the
    // MavenResolver (mavenInstaller) take the pomFilterContainer (pom) and configure the maven project
    configure(install.repositories.mavenInstaller) {
        pom.project {
            url 'http://wiki.jfrog.org/confluence/display/RTF/Build+Integration'
            licenses {
                license {
                    name 'The Apache Software License, Version 2.0'
                    url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                    distribution 'repo'
                }
            }
            mailingLists {
                mailingList {
                    name 'JFrog Mailing List'
                    subscribe 'https://lists.sourceforge.net/lists/listinfo/artifactory-users'
                    archive 'http://forums.jfrog.org/Artifactory-Users-f2377369.html'
                }
            }
            issueManagement {
                system 'jira'
                url 'http://issues.jfrog.org/jira/browse/BI'
            }
        }
    }

    task sourceJar(type: Jar) {
        from sourceSets.main.allSource
        classifier = 'sources'
    }

    task javadocJar(type: Jar, dependsOn: javadoc) {
        classifier = 'javadoc'
        from javadoc.destinationDir
    }

    uploadArchives {
        uploadDescriptor = true
    }

    artifactoryPublish {
        dependsOn build
    }

    // Add the sourceJars to non-extractor modules
    artifacts {
        published jar
        published sourceJar
        published javadocJar
    }

    install {
        configuration = configurations.published
    }

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

configure(baseProjects()) {
    version = buildInfoVersion
    status = version.status
    dependencies {
        compile "com.google.guava:guava:10.0.1"
        compile "com.thoughtworks.xstream:xstream:1.3.1"
    }

    test {
        test.useTestNG()
        testLogging {
            exceptionFormat "full"
            events "started", "passed", "skipped", "failed", "standardOut", "standardError"
            minGranularity 0
        }
    }

    artifactoryPublish {
        properties {
            all 'org.jfrog.buildinfo:build-info-*:*:*@*', 'bintray.package': 'build-info', 'bintray.version': version.toString()
        }
    }
}

// Create configurations for the extractor projects
configure(extractorProjects()) {
    it.version = new Version(it)
    it.status = version.status
    configurations {
        provided
        tools
        sources
        uberJar {
            description = 'All jars that should be included in the Uber Jar'
            transitive = true
        }
        compile {
            extendsFrom uberJar
            extendsFrom provided
        }
    }

    boolean extractorRelease = project.hasProperty('extractorRelease') //??????
    dependencies {
        //Binary depend on the latest extractor release artifact, if forced using the extractorRelease prop or if
        //release version and current extractor is snapshot. Otherwise, use project build dependency
        if (extractorRelease || (version.release && !buildInfoVersion.release)) {
            uberJar group: "$group", name: 'build-info-extractor', version: project.getProperty('build-info-latest-release-version')
        } else {
            uberJar project(':build-info-extractor')
        }
        tools group: 'com.tonicsystems.jarjar', name: 'jarjar-plugin', version: '1.0'
    }

    task jarAll(type: Jar) {
        dependsOn jar
        //Add the directory of the archive as the input files for this task
        classifier = 'uber'
        doLast {
            boolean debugJarJar = project.hasProperty('debugJarJar')
            project.ant {
                taskdef name: "jarjar", classname: "com.tonicsystems.jarjar.JarJarTask", classpath: configurations.tools.asPath
                //Zip the  project's jar (jar.archivePath) and the dependencies defined for the uberJar conf into archivePath (with classifier)
                if (debugJarJar) println "Creating Uber jar $archivePath with:"
                jarjar(jarfile: archivePath) {
                    zipfileset(src: jar.archivePath)
                    configurations.uberJar.files.each { jarjarFile ->
                        if (!jarjarFile.name.endsWith("-sources.jar")) {
                            zipfileset(src: jarjarFile)
                            if (debugJarJar) println "\t$jarjarFile"
                        }
                    }
                }
            }
        }
    }

    // Add the published artifact of the jarAll task to the list of published artifacts for the archives configuration
    artifacts {
        published jarAll
    }

    assemble {
        dependsOn jarAll
    }

    // Treat the uberJar conf as a maven compile scope so that uberJar depenedncies are transformed into compile-scope
    // dependencies in generated extractor poms
    configure(install.repositories.mavenInstaller) {
        pom.scopeMappings.addMapping(MavenPlugin.COMPILE_PRIORITY + 1, configurations.uberJar, "compile")
        pom.scopeMappings.addMapping(MavenPlugin.COMPILE_PRIORITY + 2, configurations.provided, "provided")
    }

    artifactoryPublish {
        properties {
            all 'org.jfrog.buildinfo:build-info-*:*:*@*', 'bintray.package': project.name.toString(), 'bintray.version': project.version.toString()
            all 'org.jfrog.buildinfo:artifactory-maven-plugin:*:*@*', 'bintray.package': project.name.toString(), 'bintray.version': project.version.toString()
        }
    }
}

// Declare the root project to build its children first
evaluationDependsOnChildren()

project('build-info-api') {
    description = 'JFrog Build-Info API'
}

project('build-info-client') {
    description = 'JFrog Build-Info Client'
    dependencies {
        compile project(':build-info-api')
        compile ("org.apache.httpcomponents:httpclient:4.2.5"){
            exclude module: "commons-codec"
        }
        compile "org.codehaus.jackson:jackson-mapper-asl:1.9.12"
        compile "commons-codec:commons-codec:1.8"
    }
    sourceSets {
        main {
            resources {
                srcDir 'src/main/filtered-resources'
            }
        }
    }
    processResources {//???
        from(sourceSets.main.resources.srcDirs) {
            include '**/*bi.client.properties'
            filter(ReplaceTokens, tokens: ['project.version': project.version.toString()])
        }
    }

}

project('build-info-extractor') {
    description = 'JFrog Build-Info Extractor'
    dependencies {
        compile project(':build-info-client')
        testCompile "org.easymock:easymockclassextension:2.5.2"
    }
}

project('build-info-vcs') {
    description = 'JFrog Build-Info VCS'
    dependencies {
        compile(group: 'com.perforce', name: 'p4java-jfrog', version: '2011.1.297684')
    }
}

project('build-info-extractor-ivy') {
    description = 'JFrog Build-Info Ivy Extractor'
    dependencies {
        uberJar "org.slf4j:slf4j-api:1.5.8"
        provided "com.google.code.findbugs:jsr305:1.3.9",
                "org.apache.ivy:ivy:2.2.0",
                "org.apache.ant:ant:1.8.4"
    }

    //Configure the Maven installer pom generation
    configure(install.repositories.mavenInstaller) {
        pom.project {
            issueManagement {
                system 'jira'
                url 'http://issues.jfrog.org/jira/browse/IAP'
            }
        }
    }
}

project('build-info-extractor-gradle') {
    apply plugin: 'groovy'
    description = 'JFrog Build-Info Gradle Extractor'

    println description
    dependencies {
        compile gradleApi()
        compile fileTree(dir: "${gradle.gradleHomeDir}/lib/plugins", include: '**/*.jar') //workaround for GRADLE-1699
        provided "org.codehaus.plexus:plexus-component-annotations:1.5.5",
                "com.google.code.findbugs:jsr305:1.3.9"
        compile group: 'javax.annotation', name: 'jsr250-api', version: '1.0'
        uberJar group: 'org.apache.ivy', name: 'ivy', version: '2.2.0'
        compile localGroovy()
        testCompile(group: 'org.spockframework', name: 'spock-core', version: '0.5-groovy-1.8') {
            transitive = false
        }
        testCompile(group: 'net.java.dev.jna', name: 'jna', version: '3.2.2')
    }

    test {
        systemProperties['buildInfoConfig.propertiesFile'] = ''
        environment['buildInfoConfig.propertiesFile'] = ''
    }

    configure(install.repositories.mavenInstaller) {
        pom.project {
            issueManagement {
                system 'jira'
                url 'http://issues.jfrog.org/jira/browse/GAP'
            }
        }
    }
}

project('build-info-extractor-maven3') {

    apply plugin: 'groovy'
    description = 'JFrog Build-Info Maven 3 Extractor'

    dependencies {
        compile 'org.jdom:jdom:1.1.1',
                'org.codehaus.groovy:groovy-all:2.1.6',
                'plexus:plexus-container-default:1.0-alpha-6',
                'org.apache.maven:maven-core:3.1.0',
                'org.sonatype.aether:aether-api:1.13.1',
                'org.sonatype.aether:aether-util:1.13.1',
                'org.sonatype.aether:aether-impl:1.13.1',
                'org.eclipse.aether:aether-api:0.9.0.M3',
                'org.eclipse.aether:aether-util:0.9.0.M3'
        provided    'org.codehaus.plexus:plexus-component-annotations:1.5.5'
        testCompile 'org.easymock:easymockclassextension:2.5.2'
    }

    configure(install.repositories.mavenInstaller) {
        pom.project {
            issueManagement {
                system 'jira'
                url 'http://issues.jfrog.org/jira/browse/MAP'
            }
        }
    }
}

project('artifactory-maven-plugin') {

    Project p ->

        apply plugin: 'groovy'
        description = 'JFrog Build-Info Maven 3 Plugin'

        dependencies {
            compile  project( ':build-info-api' ),
                    'org.apache.maven.plugin-tools:maven-plugin-annotations:3.2',
                    'org.gcontracts:gcontracts-core:1.2.12',
                    'org.codehaus.plexus:plexus-utils:3.0.13',
                    'org.apache.ant:ant:1.9.2'

            compile ( project( ':build-info-extractor-maven3' )) { exclude group: 'org.jdom', module: 'jdom' }
            compile ( 'org.codehaus.gmaven:gmaven-mojo:1.5'    ) { exclude group: 'org.codehaus.groovy', module: 'groovy-all-minimal' }

            testCompile 'org.spockframework:spock-core:0.7-groovy-2.0'
            provided    'org.apache.maven:maven-core:3.1.0',
                        'org.apache.maven:maven-project:2.0.11'
        }

        clean { delete( 'pom.xml' ) }

        task pluginDescriptor( type: Exec ) {
            // http://www.gradle.org/docs/current/dsl/org.gradle.api.tasks.Exec.html

            final mvn      = project.hasProperty( 'mvn'     ) ? project.mvn     : System.getProperty( 'os.name' )?.toLowerCase()?.contains( 'win' ) ? 'mvn.bat' : 'mvn'
            final mvnArgs  = project.hasProperty( 'mvnArgs' ) ? project.mvnArgs : ''
            final File pom = project.file( "$buildDir/pom.xml" )
            final allArgs  = [ '-e', '-B', '-f', pom.canonicalPath, mvnArgs, 'org.apache.maven.plugins:maven-plugin-plugin:3.2:descriptor' ].grep()

            executable mvn
            args       allArgs

            doFirst {
                assert project.compileGroovy.destinationDir.directory
                install.repositories.mavenInstaller.pom.writeTo( pom )
                assert pom.file, "[$pom.canonicalPath] was not generated"
                println "POM is generated at file:$pom.canonicalPath"

                pom.text = pom.text.
                        replace( '<groupId>unknown</groupId>',             "<groupId>${project.group}</groupId>" ).
                        replace( '<artifactId>empty-project</artifactId>', "<artifactId>${project.name}</artifactId>" ).
                        replace( '<version>0</version>',                   """
                                                                   |<version>${version}</version>
                                                                   |  <packaging>maven-plugin</packaging>
                                                                   |  <build>
                                                                   |    <directory>${project.buildDir.canonicalPath}</directory>
                                                                   |    <outputDirectory>${project.compileGroovy.destinationDir.canonicalPath}</outputDirectory>
                                                                   |  </build>""".stripMargin().trim())

                println "Running '$mvn' with arguments $allArgs"
            }
            doLast {
                final  pluginDescriptor = new File(( File ) project.compileGroovy.destinationDir, 'META-INF/maven/plugin.xml' )
                assert pluginDescriptor.file, "[$pluginDescriptor.canonicalPath] was not created"
                println "Plugin descriptor file:$pluginDescriptor.canonicalPath is created"
            }
        }

        /**
         * We need to ensure all other sub-projects are installed for 'mvn' to find their artifacts
         */
        p.rootProject.subprojects.findAll{ it.hasProperty( 'install' ) && ( it.name != p.name ) }.
                each   { pluginDescriptor.dependsOn( it.install )}
        p.jar.dependsOn( pluginDescriptor )

        configure( install.repositories.mavenInstaller ) {
            pom.project {
                issueManagement {
                    system 'jira'
                    url 'http://issues.jfrog.org/jira/browse/MAP'
                }
                repositories {
                    for ( String repoUrl in project.repositories*.url.toSet()) {
                        repository {
                            id  repoUrl.toString().replaceAll( ~/[^\w]/, '_' )
                            url repoUrl
                        }
                    }
                }
            }
        }
}

idea {
    project {
        jdkName = '1.6'
        languageLevel = '1.6'
        wildcards += '?*.gradle'
        idea.project.ipr {
            withXml { provider ->
                provider.node.component.find { it.@name == 'VcsDirectoryMappings' }.mapping.@vcs = 'Git'
            }
        }
    }

    module {
        excludeDirs += file( 'out' )
        iml.withXml {
            provider ->
                provider.node.component.first().appendNode( 'orderEntry', [ type : 'library', name : 'Groovy', level: 'application' ])
        }
    }
}


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