mps-coderules/build.gradle

import groovy.xml.MarkupBuilder
import java.util.regex.*
import java.util.zip.*
import java.io.*
import com.jetbrains.plugin.blockmap.core.BlockMap
import com.jetbrains.plugin.blockmap.core.FileHash
import com.fasterxml.jackson.databind.ObjectMapper

buildscript {
    repositories {
       mavenCentral()
    }
    dependencies {
       classpath group: 'org.jetbrains.intellij', name: 'blockmap', version: '1.0.5'
       // https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind
       classpath group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: '2.12.3'
    }
}

// In case gradle build fails to execute any of the tasks imported from
// buid.xml, try the following steps: 
//
// 1. Uncomment the following section importing the task-tree plugin
// 2. Run `./gradlew assemble taskTree --no-repeat`
//
// If the above command generates suspiciously-looking output and never
// finishes, the most likely cause is that the target definitions in Ant
// build.xml file have cyclic dependencies. This needs to be fixed in build
// script, and build.xml regenerated.

// plugins {
//  id "com.dorongold.task-tree" version "1.5"
// }

defaultTasks 'assemble'

allprojects {
  apply plugin: 'java'

  repositories {
    mavenLocal()
    mavenCentral()
  }

  // please no jars, no manifests, no build folders 
  jar { onlyIf { false } }
}

repositories {
  ivy {
      url 'https://teamcity.jetbrains.com/guestAuth/repository/download'
      patternLayout {
        ivy '[module]/[revision]/teamcity-ivy.xml'
        artifact '[module]/[revision]/[revision].[ext]'
      }
  }
}

configurations {
    junitAnt
}

dependencies {
  // initialize JUnit optional ant task
  junitAnt 'junit:junit:4.8.2'
  junitAnt('org.apache.ant:ant-junit:1.9.2') {
      transitive = false
  }
}

def allInitDependencies = [
  'coderules:solutions:jetbrains.mps.logic.reactor:copyDependencies',
  'coderules:solutions:jetbrains.mps.logic.test:copyDependencies',
  'coderules:solutions:jetbrains.mps.coderules.typechecking:copyDependencies',
  'coderules:solutions:jetbrains.mps.coderules:copyDependencies' ]

task setup(dependsOn: allInitDependencies) {
  doLast {
    println 'Initialized all dependencies.'
  }
}

def buildNumber() {
  System.env.BUILD_NUMBER =~ /MPS-([0-9]+)\.([0-9]+).([0-9]+)-([0-9]+)/
}

task generateUpdatePluginsXml {
  onlyIf {
    buildNumber().find()
  }
  doLast {
    def updatesDir = project.projectDir.absolutePath + "/build/artifacts/coderules/updates"
    mkdir(updatesDir)

    def version = "${buildNumber()[0][1]}-0.9-b${buildNumber()[0][4]}"
    def baseUrl = "https://github.com/JetBrains/mps-coderules/releases/download/v${version}"
    def zip1 = "/jetbrains.mps.coderules-${version}.zip"
    def zip2 = "/jetbrains.mps.core.types-${version}.zip"

    file(updatesDir + "/updatePlugins.xml").withWriter { w ->
       new MarkupBuilder(new IndentPrinter(w, "    ", true)).
         plugins {
           plugin( id: "jetbrains.mps.coderules" ,
                   url: baseUrl + "/" + zip1 ,
                   version: "${version}" ) {
             name { mkp.yield("MPS Coderules Typechecking") }
             description { mkp.yield("Typechecking with Coderules (experimental)") }
           }
           plugin( id: "jetbrains.mps.core.types" ,
                   url: baseUrl + "/" + zip2 ,
                   version: "${version}" ) { 
             name { mkp.yield("MPS Core Types") }
             description { mkp.yield("Types for core MPS languages (experimental)") }
           }
       }
    }
  }
}

task createBlockmap {
  onlyIf {
    buildNumber().find()
  }
  doLast {
    def version = "${buildNumber()[0][1]}-0.9-b${buildNumber()[0][4]}"
    def path = "build/artifacts/coderules"
    def distFile = file("${path}/jetbrains.mps.coderules-${version}.zip")
    def blockMapFileZipFile = new File(distFile.absolutePath + ".blockmap.zip")
    def blockMapFileZip = new ZipOutputStream(new BufferedOutputStream(new FileOutputStream(blockMapFileZipFile)))
    blockMapFileZip.putNextEntry(new ZipEntry("blockmap.json"))
    blockMapFileZip.write(new ObjectMapper().writeValueAsBytes(new BlockMap(new BufferedInputStream(new FileInputStream(distFile)), "SHA-256")))
    blockMapFileZip.closeEntry()
    blockMapFileZip.close()
    def distFileHash = new File(distFile.absolutePath + ".hash.json")
    distFileHash.append(new ObjectMapper().writeValueAsString(new FileHash(new BufferedInputStream(new FileInputStream(distFile)), "SHA-256")))
  }
}

ant.taskdef(name: 'junit',
            classname: 'org.apache.tools.ant.taskdefs.optional.junit.JUnitTask',
            classpath: configurations.junitAnt.asPath)

ant.importBuild('build.xml') { antTarget ->
    'coderules-'+antTarget
}
ant.properties.'ci.build.num' = "${buildNumber().find() ? buildNumber()[0][4] : '9999'}".toString()
ant.properties.'ci.build.tag' = "${buildNumber().find() ? buildNumber()[0][4] : 'SNAPSHOT'}".toString()
ant.properties.'ci.mps.release' = "${buildNumber().find() ? buildNumber()[0][1] : '213'}".toString()
ant.properties.'mps.ant.log' = "debug"

// ensure 'setup' runs before 'fetchDependencies' and 'declare-mps-tasks'
'coderules-fetchDependencies' {
  dependsOn {
    'setup'
  }
}

'coderules-declare-mps-tasks' {
  dependsOn {
    'setup'
  }
}

// ensure 'generate' runs before 'classes' ('generate' is NOT optional)
'coderules-classes' {
  dependsOn {
    'coderules-generate'
  }
  mustRunAfter {
    'coderules-generate'
  }
}

'coderules-assemble' {
  finalizedBy {
    [
      'generateUpdatePluginsXml'
    ]
  }
}

assemble {
  dependsOn {
    [
      ':coderules-assemble',
      ':samples:mpscore:mpscore-assemble',
      ':samples:lambdacalc:lambdacalc-assemble',
      ':samples:fitch:fitch-assemble'
    ]
  }
}

clean {
  dependsOn {
    [
      ':coderules-clean', ':coderules-cleanSources',
      ':samples:mpscore:mpscore-clean', ':samples:mpscore:mpscore-cleanSources',
      ':samples:lambdacalc:lambdacalc-clean', ':samples:lambdacalc:lambdacalc-cleanSources',
      ':samples:fitch:fitch-clean', ':samples:fitch:fitch-cleanSources'
    ]
  }
  finalizedBy {
     deleteMps
  }
}

check {
  dependsOn {
    [
      ':samples:mpscore:mpscore-check',
      ':samples:lambdacalc:lambdacalc-check',
      ':samples:fitch:fitch-check'
    ]
  }
  // tests from this target also include model checker invocation, which requires everything to be built
  finalizedBy {
    ':coderules-check'
  }
}