build.gradle

plugins {
  id 'org.jetbrains.intellij' version "0.4.10"
  id "org.jetbrains.kotlin.jvm" version "1.3.50"
  id 'de.undercouch.download' version "4.0.0"
}

ext {
  if (elixirVersion.startsWith("1.5") || elixirVersion.startsWith("1.6")) {
    quoterVersion = "1.0.0"
  } else {
    quoterVersion = "2.1.0"
  }

  cachePath = "${rootDir}/cache"

  elixirPath = "${cachePath}/elixir-${elixirVersion}"

  quoterUnzippedPath = "${cachePath}/elixir-${elixirVersion}-intellij_elixir-${quoterVersion}"

  if (elixirVersion.startsWith("1.5") || elixirVersion.startsWith("1.6") || elixirVersion.startsWith("1.7")) {
    quoterExe = "${quoterUnzippedPath}/_build/dev/rel/intellij_elixir/bin/intellij_elixir"
  } else {
    quoterExe = "${quoterUnzippedPath}/rel/intellij_elixir/bin/intellij_elixir"
  }

  quoterZipPath = "${cachePath}/intellij_elixir-${quoterVersion}.zip"
  quoterZipRootPath = "${cachePath}/intellij_elixir-${quoterVersion}"

  if (project.hasProperty("isRelease") && isRelease) {
    versionSuffix = ""
  } else {
    def date = new Date().format("yyyyMMddHHmmss", TimeZone.getTimeZone("UTC"))
    versionSuffix = "-pre+$date"
  }

  version "$baseVersion$versionSuffix"
}

allprojects {
  apply plugin: 'java'
  sourceCompatibility = javaVersion
  targetCompatibility = javaVersion
  tasks.withType(JavaCompile) { options.encoding = 'UTF-8' }
}

sourceSets {
  main {
    java.srcDirs 'src', 'gen'
    resources.srcDirs 'resources'
  }
  test {
    java.srcDir 'tests'
  }
}

allprojects {
  apply plugin: 'org.jetbrains.intellij'
  intellij {
    def intellij_erlang_version

    if (ideaVersion.startsWith("2019.2")) {
      intellij_erlang_version = "0.11.1008"
    } else if (ideaVersion.startsWith("2019.1")) {
      intellij_erlang_version = "0.11.1004"
    } else if (ideaVersion.startsWith("2018.3")) {
      intellij_erlang_version = "0.11.1000"
    } else if (ideaVersion.startsWith("2018.2")) {
      intellij_erlang_version = "0.11.985"
    } else if (ideaVersion.startsWith("2018.1")) {
      intellij_erlang_version = "0.11.976"
    } else if (ideaVersion.startsWith("2017.3")) {
      intellij_erlang_version = "0.10.966"
    } else if (ideaVersion.startsWith("2017.2")) {
      intellij_erlang_version = "0.9.958"
    } else if (ideaVersion.startsWith("2017.1.")) {
      intellij_erlang_version = "0.9.939"
    } else if (ideaVersion.startsWith("2016.3.")) {
      intellij_erlang_version = "0.9.912"
    } else {
      throw new IllegalArgumentException("ideaVersion is not a recognized MAJOR.MINOR for IntelliJ Erlang compatibility")
    }

    plugins = [// needed for jps builder
               "java",
               "org.jetbrains.erlang:${intellij_erlang_version}",
               // always have IdeaVIM installed in sandbox
               "IdeaVIM:0.48",
               "PsiViewer:3.28.93"]
    pluginName 'intellij-elixir'
    version ideaVersion
    downloadSources Boolean.valueOf(sources)
    updateSinceUntilBuild = false
  }

  patchPluginXml {
    def stripTag = { text, tag -> text.replace("<${tag}>", "").replace("</${tag}>", "") }
    def bodyInnerHTML = { path ->
      stripTag(stripTag(file(path).text, "html"), "body")
    }

    changeNotes bodyInnerHTML("resources/META-INF/changelog.html")
    pluginDescription bodyInnerHTML("resources/META-INF/description.html")
  }

  publishPlugin {
    username publishUsername
    password publishPassword
    channels publishChannels
  }
}

apply plugin: "kotlin"

//noinspection GroovyAssignabilityCheck,GrUnresolvedAccess
tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
  //noinspection GrUnresolvedAccess
  kotlinOptions {
    apiVersion = "1.2"
    jvmTarget = "1.8"
  }
}

def compilationPackages = ['org/intellij/elixir/build/**', 'org/intellij/elixir/jps/**']

test {
  environment "ELIXIR_LANG_ELIXIR_PATH", elixirPath
  environment "ELIXIR_EBIN_DIRECTORY", "${elixirPath}/lib/elixir/ebin/"
  environment "ELIXIR_VERSION", elixirVersion
  useJUnit {
    exclude compilationPackages
  }
  testLogging {
    exceptionFormat = 'full'
  }
}

task testCompilation(type: Test, group: 'Verification', dependsOn: [classes, testClasses]) {
  useJUnit {
    include compilationPackages
  }
  testLogging {
    exceptionFormat = 'full'
  }
}

repositories {
  maven { url 'http://dl.bintray.com/jetbrains/intellij-plugin-service' }
  maven { url 'https://maven-central.storage.googleapis.com' }
  mavenCentral()
}

dependencies {
  compile project('jps-builder')
  compile project('jps-shared')
  compile group: 'org.erlang.otp', name: 'jinterface', version: '1.6.1'
  compile group: 'commons-io', name: 'commons-io', version: '2.5'

  testCompile group: 'org.mockito', name: 'mockito-core', version: '2.2.9'
  testCompile group: 'org.objenesis', name: 'objenesis', version: '2.4'
}

project(':jps-builder') {
  dependencies {
    compile project(':jps-shared')
  }
}

apply plugin: 'idea'
idea {
  project {
    jdkName = javaVersion
    languageLevel = javaVersion
  }
  module {
    generatedSourceDirs += file('gen')
  }
}

task getElixir {
  doLast {
    def folder = new File(elixirPath)

    if (!folder.isDirectory() || folder.list().size() == 0) {
      download {
        src "https://github.com/elixir-lang/elixir/archive/v${elixirVersion}.zip"
        dest "${rootDir}/cache/Elixir.${elixirVersion}.zip"
        overwrite false
      }
    }

    def binFolder = new File("${elixirPath}/bin")
    if (!binFolder.isDirectory() || folder.list().size() == 0) {
      copy {
        from zipTree("${rootDir}/cache/Elixir.${elixirVersion}.zip")
        into "${rootDir}/cache/"
      }

      exec {
        workingDir elixirPath
        commandLine "make"
      }
    }
  }
}

task getQuoter {
  doLast {
    download {
      src "https://github.com/KronicDeth/intellij_elixir/archive/v${quoterVersion}.zip"
      dest quoterZipPath
      overwrite false
    }

    def folder = new File(quoterUnzippedPath)
    if (!folder.isDirectory() || folder.list().size() == 0) {
      copy {
        from zipTree(quoterZipPath)
        into cachePath
      }

      def quoterZipRootFile = new File(quoterZipRootPath)

      quoterZipRootFile.renameTo(quoterUnzippedPath)
    }
  }
}

task getQuoterDeps(dependsOn: getQuoter) {
  doLast {
    exec {
      workingDir quoterUnzippedPath
      executable "mix"
      args "deps.get"
    }
  }
}

task releaseQuoter(dependsOn: getQuoterDeps) {
  doLast {
    def file = new File(quoterExe)

    if (!file.canExecute()) {
      exec {
        workingDir quoterUnzippedPath
        executable "mix"
        args "release"
      }
    }
  }
}

compileJava {
}

compileTestJava {
  dependsOn getElixir
  dependsOn getQuoter
}

task runQuoter(type: Exec, dependsOn: releaseQuoter) {
  executable quoterExe
  args "start"
}

task stopQuoter(type: Exec, dependsOn: releaseQuoter) {
  executable quoterExe
  args "stop"
}

runIde {
  jvmArgs "-Didea.ProcessCanceledException=disabled"
}

test {
  dependsOn runQuoter
  finalizedBy stopQuoter
}