build.gradle

import org.apache.tools.ant.taskdefs.condition.Os

buildscript {
    repositories {
        mavenCentral()
        maven { url 'http://dl.bintray.com/jetbrains/intellij-plugin-service' }
    }
    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    }
}

plugins {
    id 'org.jetbrains.intellij' version '0.2.18'
    id 'net.saliman.cobertura' version '2.5.1'
    id 'com.github.kt3k.coveralls' version '2.8.1'
}


sourceSets {
    main {
        java.srcDirs 'src/main/java', 'src/main/kotlin', 'gen'
        resources.srcDirs 'src/main/resources'
    }
    test {
        java.srcDirs 'src/test/java', 'src/test/kotlin'
    }
}

version = "${version}"

apply plugin: 'kotlin'

apply plugin: 'cobertura'
cobertura.coverageFormats = ['html', 'xml'] // coveralls plugin depends on xml format report
cobertura.coverageSourceDirs = [sourceSets.main.java.srcDirs, sourceSets.main.kotlin.srcDirs, 'gen']
cobertura.coverageEncoding = 'UTF-8'
cobertura.coverageExcludes = [ '.*de.halirutan.mathematica.*', '.*uk.co.cwspencer.*' ]

allprojects {
    sourceCompatibility = javaVersion
    targetCompatibility = javaVersion

    tasks.withType(JavaCompile) {
        options.encoding = 'UTF-8'
        options.compilerArgs << "-Xlint:deprecation"
    }

    tasks.withType(Test) {
        useJUnit {
            include '**/**/*Test.*' // any Java or Kotlin class that ends with 'Test'
        }

        testLogging {
            beforeSuite { suite ->
                if (!suite.parent) { // will match the outermost suite
                    logger.lifecycle ' ----------- Building Tests -----------'
                } else if (suite.className != null) {
                    logger.lifecycle "${suite.className}:"
                }
            }

            afterTest { descriptor, result ->
                switch (result.resultType) {
                    case 'SUCCESS':
                    case 'PASSED':
                        logger.info(" {} {}", Os.isFamily(Os.FAMILY_WINDOWS)? "√":"✔", descriptor.name)
                        break
                    case TestResult.ResultType.SKIPPED.name():
                        logger.warn(" {} {}", Os.isFamily(Os.FAMILY_WINDOWS)? "!":"⛔", descriptor.name)
                        break
                    case TestResult.ResultType.FAILURE.name():
                        logger.error(" {} {}", Os.isFamily(Os.FAMILY_WINDOWS)? "×":"✘", descriptor.name)
                        break
                    default:
                        logger.lifecycle(" ? {} {}", descriptor.name, result.resultType)
                }
            }

            afterSuite { desc, result ->
                if (!desc.parent) { // will match the outermost suite
                    def output = "Results: ${result.resultType} (${result.testCount} tests, ${result.successfulTestCount} passed, ${result.failedTestCount} failed, ${result.skippedTestCount} skipped)"
                    def startItem = '|  ', endItem = '  |'
                    def repeatLength = startItem.length() + output.length() + endItem.length()
                    println('\n' + ('-' * repeatLength) + '\n' + startItem + output + endItem + '\n' + ('-' * repeatLength) + '\n')
                }
            }
        }
    }

    // take the version number defined in gradle build and use that in plugin.xml
    task initConfig(type: Copy) {
        from('src/main/resources') {
            include '**/plugin.xml'
            filter(org.apache.tools.ant.filters.ReplaceTokens, tokens: [version: version])
        }
    }

    apply plugin: 'org.jetbrains.intellij'
    intellij {
        pluginName 'intellij-dlanguage'
        version ideaVersion
        updateSinceUntilBuild false

        publishPlugin {
            username System.getenv('SB_JETBRAINS_USERNAME')
            password System.getenv('SB_JETBRAINS_PASSWORD')
            channels publishChannels
        }
    }

    task testCompilation(type: Test, group: 'Verification', dependsOn: [classes, testClasses]) {
        useJUnit {
            include 'io/github/intellij/dlanguage/build/**'
        }
        testLogging {
            exceptionFormat = 'full'
        }
    }
}

repositories {
    mavenCentral()
}

dependencies {
    // According to https://www.jetbrains.org/intellij/sdk/docs/tutorials/kotlin.html
    // we should not include kotlin-runtime and kotlin-stdlib jars with your plugin
    compileOnly "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
    compileOnly "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"

    compile 'org.eclipse.mylyn.github:org.eclipse.egit.github.core:2.1.5'
    compile ('io.sentry:sentry:1.6.1'){
        exclude group: 'org.slf4j'
    }
    testCompile 'io.kotlintest:kotlintest:2+'
}

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

    }
}
compileKotlin {
    kotlinOptions {
        apiVersion = "1.2"
    }
}