build.gradle

import java.nio.file.Files
import java.nio.file.Path as JPath
import java.nio.file.StandardCopyOption
import java.util.jar.JarEntry
import java.util.jar.JarInputStream
import java.util.regex.Pattern

plugins {
    id "java"
    id "application"
    id "com.github.johnrengelman.shadow" version "7.1.2"
    id "antlr"
    id "org.jetbrains.kotlin.jvm" version "1.6.20-RC"
}

group "io.github.seggan.jyxal"
version "0.5.1"

mainClassName = "io.github.seggan.jyxal.Main"

JPath dest = JPath.of("$buildDir/runtime-classes/")

repositories {
    mavenCentral()
}

configurations {
    runtimeLib
}

dependencies {
    implementation 'org.ow2.asm:asm:9.3'
    implementation 'org.ow2.asm:asm-commons:9.3'
    implementation 'org.ow2.asm:asm-util:9.3'

    implementation 'org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.6.21'
    runtimeLib("org.jetbrains.kotlin:kotlin-stdlib:1.6.21") {
        transitive = false
    }
    runtimeLib("org.jetbrains:annotations:23.0.0") {
        transitive = false
    }

    implementation "com.guardsquare:proguard-base:7.2.1"

    implementation 'org.matheclipse:matheclipse-core:2.0.0'
    runtimeLib("org.matheclipse:matheclipse-core:2.0.0") {
        transitive = false
    }

    antlr 'org.antlr:antlr4:4.10.1'

    testImplementation "org.junit.jupiter:junit-jupiter-api:5.8.2"
    testImplementation 'org.jetbrains.kotlin:kotlin-reflect:1.6.21'
    testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:5.8.2"
}

test {
    useJUnitPlatform()
    minHeapSize = "128m"
    maxHeapSize = "512m"
}

generateGrammarSource {
    maxHeapSize = "128m"
    JPath path = JPath.of("$buildDir/generated-src/")
    JPath fullPath = path.resolve("antlr/main/io/github/seggan/jyxal/antlr/")
    Files.createDirectories(fullPath)
    doFirst {
        Files.createDirectories(fullPath)
    }
    arguments += ["-lib", fullPath.toAbsolutePath().toString(), "-visitor", "-no-listener", "-encoding", "UTF-8", "-package", "io.github.seggan.jyxal.antlr"]
}

compileJava {
    dependsOn generateGrammarSource

    sourceCompatibility = "11"
    targetCompatibility = "11"
}

sourceSets {
    main {
        java {
            srcDir "src/main/antlr"
        }
        java.srcDirs += "build/generated-src/antlr/main/"
    }
}

task extractLibs() {
    doLast {
        JPath list = dest.resolve("runtime.list")
        if (!Files.exists(list)) {
            Files.createDirectories(dest)
            Files.createFile(list)
        }
        Set<String> classes = new HashSet<>(Files.readAllLines(list))
        for (File f : configurations.runtimeLib.resolve()) {
            try (JarInputStream inputStream = new JarInputStream(new FileInputStream(f))) {
                JarEntry entry
                while ((entry = inputStream.getNextJarEntry()) != null) {
                    if (entry.isDirectory() || !entry.getName().endsWith(".class")) {
                        continue
                    }
                    JPath d = dest.resolve(entry.getName())
                    if (Files.exists(d)) {
                        continue
                    }
                    Files.createDirectories(d.getParent())
                    Files.copy(inputStream, d, StandardCopyOption.REPLACE_EXISTING)
                    classes.add(entry.getName())
                }
            }
        }
        Files.write(list, classes)
    }
}

task copyRuntime() {
    dependsOn extractLibs, compileJava, compileKotlin
    doLast {
        JPath list = dest.resolve("runtime.list")
        if (!Files.exists(list)) {
            Files.createDirectories(dest)
            Files.createFile(list)
        }
        Set<String> names = new HashSet<>(Files.readAllLines(list))
        String dir = "$buildDir/classes/"
        Pattern regex = Pattern.compile("${buildDir.toString().replace("\\", "/")}/classes/(java|kotlin)/main/")
        Files.walk(JPath.of(dir))
                .filter(Files::isRegularFile)
                .filter(f -> f.toString().contains("runtime"))
                .filter(f -> f.toString().contains("main"))
                .forEach(f -> {
                    String rel = regex.matcher(f.toString().replace("\\", "/")).replaceAll("")
                    JPath d = dest.resolve(rel)
                    Files.createDirectories(d.getParent())
                    Files.copy(f, d, StandardCopyOption.REPLACE_EXISTING)
                    names.add(rel)
                })
        names.add("dictLong.txt")
        names.add("dictShort.txt")
        Files.write(dest.resolve("runtime.list"), names)
    }
}

test {
    dependsOn copyRuntime
}

clean {
    delete "generated-src"
    delete "runtime-classes"
}

// copy and relocate the runtime into the resources
shadowJar {
    dependsOn test

    from(dest.toFile().path) {
        include "**/*.*"
    }

    for (File f : sourceSets.main.resources.srcDirs) {
        from(f) {
            include "**/*.*"
        }
    }

    from(rootDir) {
        include "LICENSE.txt"
    }

    archiveFileName = "Jyxal v${project.version}.jar"
}
compileKotlin {
    dependsOn generateGrammarSource

    kotlinOptions {
        jvmTarget = "11"
        freeCompilerArgs += ["-Xno-param-assertions"]
    }
}

compileTestKotlin {
    dependsOn compileKotlin
    dependsOn generateTestGrammarSource

    kotlinOptions {
        jvmTarget = "11"
    }
}