build.gradle

buildscript {
    ext.kotlinVersion = '1.0.5'
    ext.javaVersion = '1.6'

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

    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"
    }
}

plugins {
    id 'org.jetbrains.intellij' version "0.1.10"
}


allprojects {
    apply plugin: 'idea'
    idea {
        module {
            generatedSourceDirs += file('src/gen')
        }
    }

    apply plugin: 'org.jetbrains.intellij'
    intellij {
        version ideaVersion
        downloadSources Boolean.valueOf(downloadIdeaSources)
        // FIXME: hack to support both IDEA 15 and IDEA 16.
        // See https://github.com/intellij-rust/intellij-rust/issues/243
        updateSinceUntilBuild = false
        instrumentCode = false

        publish {
            username publishUsername
            password publishPassword
            channel publishChannel
        }
    }

    apply plugin: 'java'
    apply plugin: 'kotlin'

    sourceCompatibility = javaVersion
    targetCompatibility = javaVersion

    tasks.withType(JavaCompile) { options.encoding = 'UTF-8' }
    sourceSets {
        main {
            java.srcDirs += 'src/gen'
            // Exclude miglayout bundled with the IDE because we need a newer version, which
            // is only available since 2016.3
            compileClasspath = compileClasspath.filter { it.name != 'miglayout-swing.jar' }
        }
    }

    test {
        testLogging {
            events 'skipped', 'failed'
            exceptionFormat = 'full'
        }

        beforeSuite { suite ->
            if (suite.className != null) {
                println()
                println(suite.className)
            }
        }
        afterTest { desc, result ->
            def c = '.'
            if (result.resultType == TestResult.ResultType.FAILURE) {
                c = 'X'
            } else if (result.resultType == TestResult.ResultType.SKIPPED) {
                c = 'S'
            }
            print(c)
            System.out.flush()
        }
        afterSuite { println() }
    }

    repositories {
        mavenCentral()
        maven { url 'http://dl.bintray.com/jetbrains/markdown' }
        maven { url 'https://jitpack.io' }
    }

    dependencies {
        compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion"
        compile "org.jetbrains.kotlin:kotlin-runtime:$kotlinVersion"
        compile('com.github.matklad:miglayout:afbdb74067') {
            exclude module: 'org-netbeans-api-annotations-common'
        }

        testCompile 'junit:junit:4.+'
        testCompile 'org.assertj:assertj-core:3.2.0'
    }
}

project(':') {
    version = "0.1.0.$buildNumber" + (publishChannel?.trim() ? "-$publishChannel" : "")
    intellij { pluginName 'intellij-rust' }
}

project(':toml') {
    version = "0.0.1.$buildNumber" + (publishChannel?.trim() ? "-$publishChannel" : "")
    intellij { pluginName 'intellij-toml' }
}

test {
    useJUnit {
        excludeCategories 'org.rust.Performance'
    }
}

task performanceTest(type: Test, group: 'Verification', dependsOn: [classes, testClasses]) {
    useJUnit {
        includeCategories 'org.rust.Performance'
        reports.html.destination = "$buildDir/reports/performanceTests"
    }

    testLogging {
        events 'passed', 'skipped', 'failed'
        showStandardStreams = true
        exceptionFormat = 'full'
    }

    outputs.upToDateWhen { false } // always execute task, even if already executed.
}

check.dependsOn performanceTest


dependencies {
    compile 'org.jetbrains:markdown:0.1.12'
}

lexerTask(project, 'RustLexer', 'org/rust/lang/core/lexer')
lexerTask(project, 'RustDocHighlightingLexer', 'org/rust/lang/doc/lexer')
parserTask(project, 'RustParser', 'org/rust/lang/core/psi')

project(':toml') {
    lexerTask(project, 'TomlLexer', 'org/toml/lang/core/lexer')
    parserTask(project, 'TomlParser', 'org/toml/lang/core/psi')
}

static def codegenTask(project, task) {
    project.compileKotlin.dependsOn task
    project.compileTestKotlin.dependsOn task
    return task
}

def lexerTask(project, lexerName, pkg) {
    return codegenTask(project, tasks.create("generate${lexerName}", JavaExec) {
        def src = "$project.projectDir/src/main/grammars/${lexerName}.flex"
        def dst = "$project.projectDir/src/gen/$pkg"

        main = 'jflex.Main'
        classpath = files('lib/jflex/jflex-1.7.0-SNAPSHOT.jar')

        args = ['--skel', 'lib/jflex/idea-flex.skeleton',
                '-d', dst,
                src
        ]

        inputs.file file(src)
        outputs.dir file("$dst/_${lexerName}.java")
    })
}

def parserTask(project, parserName, pkg) {
    return codegenTask(project, tasks.create("generate${parserName}", JavaExec) {
        def dstRoot = "$project.projectDir/src/gen"
        def src = "$project.projectDir/src/main/grammars/${parserName}.bnf"
        def dst = "$dstRoot/$pkg"
        doFirst {
            delete file(dst)
        }

        main = 'org.intellij.grammar.Main'
        classpath(configurations.compile + files('lib/grammar-kit.jar'))

        args = [dstRoot, file(src)]

        inputs.file file(src)
        outputs.dir fileTree(dir: dst, include: '**/*.java')
    })
}