build.gradle

gradle.startParameter.showStacktrace = ShowStacktrace.ALWAYS
gradle.startParameter.logLevel = LogLevel.DEBUG

buildscript {
  repositories {
    mavenCentral()
    jcenter()
    maven { url "https://oss.sonatype.org/content/repositories/snapshots" }
  }
  dependencies {
    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"

    classpath "com.google.gradle:osdetector-gradle-plugin:$osDetectorVersion"

    classpath "com.satori:satori-libs-gradle-utils:$composerVersion"
    classpath "com.satori:satori-libs-gradle-docker:$composerVersion"
    classpath "com.satori:satori-libs-gradle-transform:$composerVersion"
    classpath "com.satori:satori-libs-gradle-codegen:$composerVersion"
    classpath "com.satori:satori-gradle-composer-plugin:$composerVersion"
  }
}

group group
version version
buildDir = ".out"

apply plugin: "com.google.osdetector"
apply plugin: "com.satori.codegen"
apply plugin: 'com.satori.docker'
apply plugin: 'com.satori.transform'
apply plugin: 'com.satori.composer'
apply plugin: "idea"

idea {
  project {
    jdkName = JavaVersion.VERSION_1_10.toString()
    languageLevel = JavaVersion.VERSION_1_10.toString()
  }
  module {
    inheritOutputDirs = false
    outputDir = file("$buildDir/idea")
    testOutputDir = file("$buildDir/idea-tests")
  }
}


apply plugin: "java"
//apply plugin: 'java-library'

sourceCompatibility = JavaVersion.VERSION_1_10
targetCompatibility = JavaVersion.VERSION_1_10

ext {
  pckg = "$group.${codeFormatter.packageName(project.name)}"
  pckgDir = pckg.replace('.', '/')
}

sourceSets.main.java.srcDirs = ['src']
sourceSets.main.resources.srcDirs = ['res']
sourceSets.test.java.srcDirs = ['tests/src']
sourceSets.test.resources.srcDirs = ['tests/res']

apply plugin: "kotlin"

kotlin {
  experimental {
    coroutines 'enable'
  }
}

tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
  kotlinOptions {
    jvmTarget = JavaVersion.VERSION_1_8
    //freeCompilerArgs = ['-Xallow-kotlin-package']
  }
}

sourceSets.main.kotlin.srcDirs = sourceSets.main.java.srcDirs
sourceSets.test.kotlin.srcDirs = sourceSets.test.java.srcDirs

sourceSets.main.kotlin.exclude "**/*.java"
//sourceSets.main.kotlin.filter.excludes("module-info.java")

task showSources{
  doFirst{
    sourceSets.main.kotlin.forEach{
      println "kotlin source: $it"
    }
  }
}


// TODO: fix it
/*
compileKotlin {
  compileJava.dependsOn it
  //destinationDir = compileJava.destinationDir
}

compileTestKotlin {
  compileTestJava.dependsOn it
  //destinationDir = compileTestJava.destinationDir
}
*/

/*task createDefaultProjectStructure {
  group 'init'
  doLast {
    println "creating default project structure for project '${project.name}'..."

    // create directories for all source sets
    sourceSets.forEach { sourceSet ->
      sourceSet.java.srcDirs.forEach {
        def pathToCreate = new File(it, pckgDir)
        println "creating sources path for '${sourceSet.name}': '$pathToCreate'"
        pathToCreate.mkdirs()
      }
      sourceSet.resources.srcDirs.forEach {
        def pathToCreate = new File(it, pckgDir)
        println "creating resources path for '${sourceSet.name}': '$pathToCreate'"
        pathToCreate.mkdirs()
      }
    }

    // generate build.gradle
    if (!file("build.gradle").exists() && file("build.template.gradle").exists()) {
      println "creating build.gadle: '${file('build.gradle')}'"
      transform {
        template = rootProject.file('build.template.gradle')
        output = file('build.gradle')
      }
    }
  }
}*/

/*sourceSets.all { sourceSet ->
  def n = sourceSet.name
  n = n != "main" ? n.capitalize() : ""
  def taskName = "generate${n}Code"
  println "defining task: '${project.name}:${taskName}'"
  def t = task "generate${n}Code"() {
    group 'codegen'
  }
  tasks["compile${n}Java"].dependsOn t
  tasks["compile${n}Kotlin"].dependsOn t
}*/

repositories {
  //jcenter()
  mavenCentral()
  //maven { url "https://oss.sonatype.org/content/repositories/snapshots" }
}

jar {
  manifest {
    attributes "Main-Class": "${pckg}.App"
  }
}


//
task link() {
  group "build"
  dependsOn clean
  dependsOn jar

  def javaHome = System.getProperty('java.home')
  println "javaHome='$javaHome'"
  def outDir = new File(buildDir, "dist")

  doFirst {
    delete outDir
    exec{
      workingDir buildDir
      commandLine = [
        "${javaHome}/bin/jlink",
        "--module-path", (["libs", "${javaHome}/jmods"] + sourceSets.main.compileClasspath*.path).join(File.pathSeparator),
        "--add-modules", "mymodule",
        "--launcher", "app=mymodule/org.andreyko.j9exec.App",
        //"--strip-debug",
        //"--compress", "2",
        //"--no-header-files",
        //"--no-man-pages",
        "--output", outDir
      ]
      println "> ${commandLine.join(' ')}"
    }
  }
}

task copyDependencies{
  doFirst{
    delete file("!ext")
    copy{
      //from sourceSets.main.compileClasspath
      from configurations.compile
      into file("!ext")
    }
  }

}

compileJava{
  options.verbose = true
  doFirst {
   /* options.compilerArgs = [
      '--module-path', classpath.asPath,
    ]*/
    //classpath = classpath.asPath
  }
}

jar{
  from {
    configurations.compile.collect { it.isDirectory() ? it : zipTree(it) }
  }
}

// main dependencies
dependencies {
  implementation gradleApi()
  implementation "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"

  compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion"
  //implementation "org.jetbrains.kotlin:kotlin-stdlib"
  //implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlinCoroutinesVersion"

  //implementation satoriLibsAsyncKotlin()
  //implementation satoriLibsCommonKotlin()
}