build.gradle

/*
 * Copyright (c) 2007-2014 Concurrent, Inc. All Rights Reserved.
 *
 * Project and contact information: http://www.cascading.org/
 *
 * This file is part of the Cascading project.
 *
 * 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.
 */

/*
 Using:

 To run a single test w/ gradle 1.10 and above, works with :test and :platformTest tasks
  > gradle :cascading-local:test --tests *LocalTapPlatformTest -i

 or a single method
  > gradle :cascading-local:test --tests *LocalTapPlatformTest.testIO -i

 Prior to 1.10:
 To run a single test:
   > gradle -Dtest.single=LocalTapPlatformTest :cascading-local:test -i

 To run a single platform test:
   > gradle -DplatformTest.single=CoGroupFieldedPipesPlatformTest :cascading-local:platformTest -i

 To remotely debug use
   -Dtest.debug

*/

buildscript {
  repositories {
    maven { url 'http://repo.spring.io/plugins-release' }
  }
  dependencies {
    classpath 'org.springframework.build.gradle:propdeps-plugin:0.0.5'
  }
}

configure( subprojects ) {
  apply plugin: 'propdeps'
  apply plugin: 'propdeps-maven'
  apply plugin: 'propdeps-idea'
  apply plugin: 'propdeps-eclipse'
}

apply from: 'etc/version.gradle'
apply from: "etc/s3Upload.gradle"

configurations {
  s3AntTask
}

ext.distDir = mkdir( "${rootDir}/build/dist" )

allprojects {

  apply plugin: 'java'
  apply plugin: 'idea'
  apply plugin: 'eclipse'

  sourceCompatibility = 1.7
  targetCompatibility = 1.7

  repositories {
    mavenLocal()
    mavenCentral()
    maven { url = 'http://conjars.org/repo/' }
    maven { url = 'https://repository.apache.org/content/repositories/releases/' }
  }
}

subprojects {

  apply plugin: 'maven'
  apply from: '../etc/testing.gradle'

  group = 'cascading'
  version = releaseVersion

  configurations {

    testArtifacts {
      extendsFrom testRuntime
    }
  }

  javadoc {

    def copyright = '<i>Copyright &#169; 2007-2014 Concurrent, Inc. All Rights Reserved.</i>'

    title = "Cascading ${releaseVersion}"
    destinationDir = file( "${distDir}/javadoc/${project.name}" )

    failOnError = false

    configure( options ) {
      linkSource = true
      encoding = "UTF8"
      bottom = copyright
      links = [
              'http://docs.oracle.com/javase/7/docs/api/',
              'http://dist.codehaus.org/janino/javadoc/',
              'http://junit.sourceforge.net/javadoc/'
      ]
    }
  }

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

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

  task testsJar( type: Jar, dependsOn: testClasses ) {
    from sourceSets.test.output
    classifier = 'tests'
  }

  task testSourcesJar( type: Jar, dependsOn: classes ) {
    from sourceSets.test.allSource
    classifier = 'test-sources'
  }

  artifacts {
    archives jar
    archives sourcesJar
    archives javadocJar
    archives testsJar
    archives testSourcesJar
    testArtifacts testsJar
    testArtifacts testSourcesJar
  }

  dependencies {
    testCompile group: 'junit', name: 'junit', version: '4.11'
  }

  test {
    include '**/*Test.class'
    ignoreFailures = !System.getProperty( 'test.haltonerror', "true" ).equals( "true" )
  }

  assemble << {

    if( project.name.equals( 'cascading-platform' ) )
      return

    copy {
      into "${distDir}/lib/${archivesBaseName}"
      from( configurations.compile.resolvedConfiguration.firstLevelModuleDependencies.findAll { dep ->
        !dep.name.contains( 'cascading' )
      }.collect { dep ->
        dep.moduleArtifacts.collect { it.file }
      } )
    }

    copy {
      into distDir
      from configurations.default.allArtifacts.files
    }
  }

  uploadArchives {

    def deployer = repositories.mavenDeployer {
      configuration = configurations.archives

      repository( url: repoUrl ) {
        authentication( userName: repoUserName, password: repoPassword )
      }

      pom.project {
        description 'An API for data management, analytics, and machine learning on parallel computing clusters.'
        inceptionYear '2007'
        url 'http://cascading.org/'
        scm {
          url 'https://github.com/Cascading/cascading.git'
        }
        licenses {
          license {
            name 'The Apache Software License, Version 2.0'
            url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
            distribution 'repo'
          }
        }
      }
    }
    // make sure test dependencies come first, so that maven isn't getting
    // confused, when reading the generated pom
    [install.repositories.mavenInstaller, deployer]*.pom*.whenConfigured { pom ->
      def scopeOrder = [test: 1, runtime: 2, provided: 3, compile: 4].withDefault { 100 }
      pom.dependencies = pom.dependencies.sort { scopeOrder[ it.scope ] }
    }
  }
}

task prepareRelease( type: Copy, dependsOn: ['cascading-core:build', 'cascading-local:build', 'cascading-hadoop:build', 'cascading-hadoop2-mr1:build', 'cascading-hadoop2-tez:build', 'cascading-xml:build', 'cascading-platform:build'] ) {

  s3UploadDocs.dependsOn << prepareRelease
  s3UploadArtifacts.dependsOn << prepareRelease

  // copy dist and apply any analytics scripts
  def analytics = System.getProperty( 'publish.docs.analytics', '' )

  from "${distDir}/javadoc/"
  into "${s3UploadDocs.source}/javadoc"

  filter { line ->
    line.replaceAll( "</body>", "${analytics}\n</body>" )
  }
}

prepareRelease << {
  logger.info( 'built all artifacts' )
}

javadoc.enabled = false

task buildDist( dependsOn: [prepareRelease, javadoc] ) << {

  copy {
    from 'CHANGES.txt'
    from 'README.txt'
    from 'apl.txt'
    from 'LICENSE.txt'
    into distDir
  }
}

task buildPackage( type: Tar, dependsOn: buildDist ) {

  description = "package current build, does not run tests"

  destinationDir = file( s3UploadArtifacts.source )
  baseName = "cascading-${releaseVersion}"
  compression = "GZIP"

  into( baseName ) {
    from distDir
  }
}

task buildLatestMeta( dependsOn: buildPackage ) {

  s3UploadArtifacts.dependsOn << buildLatestMeta

  ext.latestArchivePath = null
  ext.latestReleaseTagPath = null
  ext.latestPropertiesPath = null
}

buildLatestMeta << {

  def destination = s3UploadArtifacts.source
  def releaseTar = buildPackage.archivePath.name

  latestArchivePath = new File( destination, 'latest.txt' )
  latestArchivePath.write( "http://${s3UploadArtifacts.destination}${releaseTar}" )

  latestReleaseTagPath = new File( destination, 'latest-tag.txt' )
  latestReleaseTagPath.write( "${releaseTag}" )

  latestPropertiesPath = new File( destination, 'latest.properties' )
  latestPropertiesPath.write( "cascading.release.version=${releaseVersion}\n" +
          "cascading.release.major=${majorVersion}\n" +
          "cascading.release.minor=${minorVersion}\n" +
          "cascading.release.build=${buildNumber}\n" +
          "cascading.release.commit=${currentCommit}\n" +
          "cascading.release.tag=${releaseTag}"
  )
}