build.gradle

import com.github.zafarkhaja.semver.Version
import org.ajoberstar.gradle.git.release.opinion.Strategies
import org.ajoberstar.gradle.git.release.opinion.Strategies.BuildMetadata
import org.ajoberstar.gradle.git.release.opinion.Strategies.PreRelease
import org.ajoberstar.gradle.git.release.semver.ChangeScope
import org.ajoberstar.gradle.git.release.semver.PartialSemVerStrategy
import org.ajoberstar.gradle.git.release.semver.SemVerStrategy
import org.ajoberstar.gradle.git.release.semver.SemVerStrategyState
import org.ajoberstar.gradle.git.release.semver.TagUtil
import org.ajoberstar.grgit.Grgit

import static org.ajoberstar.gradle.git.release.semver.StrategyUtil.all
import static org.ajoberstar.gradle.git.release.semver.StrategyUtil.closure
import static org.ajoberstar.gradle.git.release.semver.StrategyUtil.parseIntOrZero

final class VersionUtils {
  final static Version getNearestPreReleaseVersion(Grgit grgit, SemVerStrategyState state, String label) {
    List versionTags = grgit.tag.list().inject([]) { list, tag ->
      Version version = TagUtil.parseAsVersion(tag)
      if (version) {
        if (grgit.isAncestorOf(tag, state.currentHead)) {
          def reachableCommitLog = grgit.log {
            range tag.commit.id, state.currentHead.id
          }
          def distance = reachableCommitLog.size()
          def data = [version: version, distance: distance]
          list << data
        }
      }
      list
    }

    Map preRelease = versionTags.findAll { versionTag ->
      versionTag.version.preReleaseVersion.contains(label)
    }.min { a, b ->
      a.distance <=> b.distance ?: (a.version <=> b.version) * -1
    }
    return preRelease.version
  }
}

final class VersionStrategies {

  private Grgit grgit

  public VersionStrategies(Grgit grgit) {
    this.grgit = grgit
  }

  final class Normal {

    private Grgit grgit

    public Normal(Grgit grgit) {
      this.grgit = grgit
    }

    final PartialSemVerStrategy INCREMENT_FROM_PRE_RELEASE = closure { state ->
      def nearestAny = state.nearestVersion.any
      if ("dev".equals(state.stageFromProp) && ("".equals(nearestAny.preReleaseVersion) || nearestAny.preReleaseVersion.contains("rc"))) {
        switch (state.scopeFromProp) {
          case ChangeScope.MAJOR:
            return state.copyWith(inferredNormal: nearestAny.incrementMajorVersion())
          case ChangeScope.MINOR:
            return state.copyWith(inferredNormal: nearestAny.incrementMinorVersion())
          case ChangeScope.PATCH:
            return state.copyWith(inferredNormal: nearestAny.incrementPatchVersion())
          default:
            return state
        }
      } else if ("rc".equals(state.stageFromProp)) {
        if ("".equals(nearestAny.preReleaseVersion)) {
          return state.copyWith(inferredNormal: nearestAny.incrementPatchVersion())
        } else if (state.scopeFromProp == ChangeScope.PATCH) {
          def rcVersion = VersionUtils.getNearestPreReleaseVersion(grgit, state, "rc")
          return state.copyWith(inferredNormal: rcVersion.normalVersion)
        } else {
          return state.copyWith(inferredNormal: nearestAny.normalVersion)
        }
      } else {
        return state.copyWith(inferredNormal: nearestAny.normalVersion)
      }
    }
  }

  final class PreRelStrategies {

    private Grgit grgit
    private String preReleaseLabel

    public PreRelStrategies(Grgit grgit, String preReleaseLabel) {
      this.grgit = grgit
      this.preReleaseLabel = preReleaseLabel
    }

    final PartialSemVerStrategy COUNT_INCREMENTED = closure { state ->
      def nearest = state.nearestVersion
      def nearestPreRelease
      def nearestRc = VersionUtils.getNearestPreReleaseVersion(grgit, state, "rc")

      def currentPreIdents = state.inferredPreRelease ? state.inferredPreRelease.split('\\.') as List : []
      if (preReleaseLabel.equals("rc") || (preReleaseLabel.equals("dev") && nearestRc.preReleaseVersion.equals("rc.1") && nearest.any.normalVersion != state.inferredNormal)){
        nearestPreRelease = nearestRc
      } else {
        nearestPreRelease = VersionUtils.getNearestPreReleaseVersion(grgit, state, "dev")
      }
      if (nearestPreRelease == nearest.normal || nearestPreRelease.normalVersion != state.inferredNormal) {
        currentPreIdents << '1'
      } else {
        def nearestPreIdents = nearestPreRelease.preReleaseVersion.split('\\.')
        if (nearestPreIdents.size() <= currentPreIdents.size()) {
          currentPreIdents << '1'
        } else if (currentPreIdents == nearestPreIdents[0..(currentPreIdents.size() - 1)]) {
          def count = parseIntOrZero(nearestPreIdents[currentPreIdents.size()])
          currentPreIdents << Integer.toString(count + 1)
        } else {
          currentPreIdents << '1'
        }
      }
      return state.copyWith(inferredPreRelease: currentPreIdents.join('.'))
    }
  }

  final SemVerStrategy FEATURE_BRANCH = Strategies.DEFAULT.copyWith(
          name: 'feature-branch',
          stages: ['fb'] as SortedSet,
          allowDirtyRepo: true,
          preReleaseStrategy: all(PreRelease.STAGE_FLOAT, PreRelease.COUNT_COMMITS_SINCE_ANY, PreRelease.SHOW_UNCOMMITTED),
          buildMetadataStrategy: BuildMetadata.COMMIT_ABBREVIATED_ID,
          createTag: false
  )

  final SemVerStrategy DEV = Strategies.DEFAULT.copyWith(
          name: 'development',
          stages: ['dev'] as SortedSet,
          allowDirtyRepo: true,
          normalStrategy: new Normal(grgit).INCREMENT_FROM_PRE_RELEASE,
          preReleaseStrategy: all(PreRelease.STAGE_FIXED, new PreRelStrategies(grgit, "dev").COUNT_INCREMENTED)
  )

  final SemVerStrategy RC = Strategies.DEFAULT.copyWith(
          name: 'pre-release',
          stages: ['rc'] as SortedSet,
          allowDirtyRepo: true,
          normalStrategy: new Normal(grgit).INCREMENT_FROM_PRE_RELEASE,
          preReleaseStrategy: all(PreRelease.STAGE_FIXED, new PreRelStrategies(grgit, "rc").COUNT_INCREMENTED),
          enforcePrecedence: false
  )

  final SemVerStrategy FINAL = Strategies.DEFAULT.copyWith(
          name: 'release',
          stages: ['final'] as SortedSet,
          allowDirtyRepo: true,
          enforcePrecedence: false
  )
}

buildscript {
  repositories {
    mavenCentral()
    jcenter()
  }
  dependencies {
    classpath "org.ajoberstar:gradle-git:1.2.0"
    classpath "com.smokejumperit.gradle.license:Gradle-License-Report:0.0.2"
  }
}

if (project.hasProperty("release.stage")) {
  apply plugin: 'org.ajoberstar.release-opinion'

  release {
    grgit = Grgit.open(project.file('.'))

    VersionStrategies versionStrategies = new VersionStrategies(grgit)

    versionStrategy versionStrategies.FINAL
    versionStrategy versionStrategies.RC
    versionStrategy versionStrategies.FEATURE_BRANCH
    versionStrategy versionStrategies.DEV

    defaultVersionStrategy = versionStrategies.FEATURE_BRANCH

    tagStrategy {
      prefixNameWithV = false
    }
  }
}
def env = project.hasProperty('env') ? project.getProperty('env') : 'local'
ext.config = new ConfigSlurper(env).parse(file("$rootDir/gradle/config/buildConfig.groovy").toURL())

allprojects {
  apply plugin: 'idea'
  apply plugin: 'eclipse'
  group = 'com.sequenceiq'
  configurations {
    testRuntime {
      exclude group: "org.springframework.cloud"
    }
  }

}

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

  sourceCompatibility = 1.8
  targetCompatibility = 1.8

  configurations {
    deployerJars
    all*.exclude group: 'org.slf4j', module: 'slf4j-log4j12'
    all*.exclude group: 'com.google.guava', module: 'guava-jdk5'
  }

  dependencies {
    deployerJars("org.springframework.build.aws:org.springframework.build.aws.maven:3.0.0.RELEASE")
  }

  uploadArchives {
    repositories {
      mavenDeployer {
        configuration = configurations.deployerJars
        repository(url: "s3://maven.sequenceiq.com/releases") {
          authentication(userName: "$System.env.AWS_ACCESS_KEY", passphrase: "$System.env.AWS_SECRET_ACCESS_KEY")
        }
        snapshotRepository(url: "s3://maven.sequenceiq.com/snapshots") {
          authentication(userName: "$System.env.AWS_ACCESS_KEY", passphrase: "$System.env.AWS_SECRET_ACCESS_KEY")
        }
      }
    }
  }

  checkstyle {
    toolVersion = "7.6"
  }

  checkstyleMain {
    ignoreFailures = false
    configFile = rootProject.file('config/checkstyle/checkstyle.xml')
    configProperties = ['config_loc': "$rootDir/config/checkstyle"]
  }

  checkstyleTest {
    ignoreFailures = false
    configFile = rootProject.file('config/checkstyle/checkstyle.xml')
    configProperties = ['config_loc': "$rootDir/config/checkstyle"]
  }

  dependencies {
    checkstyle('com.puppycrawl.tools:checkstyle:6.11.1') {
      exclude group: 'com.google.guava'
    }
    checkstyle("com.google.guava:guava:21.0") { force = true }
  }

  task allDeps(type: DependencyReportTask) {}

  repositories {
    mavenCentral()
    maven { url "http://maven.sequenceiq.com/releases" }
    maven { url "http://repo.spring.io/milestone" }
    maven { url "https://repo.spring.io/snapshot" }
    maven { url "https://repo.spring.io/release" }
    mavenLocal()
  }
}