build.gradle

import java.nio.file.Files
import java.nio.file.Paths

import org.gradle.nativeplatform.platform.internal.DefaultNativePlatform


plugins {
    id 'java'

    id 'application'
    id 'maven-publish'

    id 'de.undercouch.download' version '5.4.0'

    id 'com.vaadin' version "${vaadinVersion}"
    id 'io.spring.dependency-management' version '1.1.0'
    id 'org.springframework.boot' version "${springBootVersion}"
}


group 'co.zimmermann'
version '0.1.0-SNAPSHOT'

sourceCompatibility = 17
targetCompatibility = 17


final isWindows = DefaultNativePlatform.currentOperatingSystem.windows

final onWindows = {
    if (isWindows) {
        it.call()
    }
}


// ext.pythonZip = "python-3.9.13-embed-amd64.zip"
// ext.pythonDownloadUrl = "https://www.python.org/ftp/python/3.9.13/${pythonZip}"

ext.minicondaInstaller = 'Miniconda3-py39_4.12.0-Windows-x86_64.exe'
ext.minicondaDownloadUrl = "https://repo.anaconda.com/miniconda/${minicondaInstaller}"


([compileJava] + (tasks.withType JavaExec)).each { it.doFirst {
    [
            [project.ext.pythonDir, "Python prefix dir"],
            [project.ext.pythonPath, "Python module search path"],
            [project.ext.jepDir, "Python/JEP package dir"],
            [project.ext.jepVersion, "Python/JEP package version"],

    ].each { final value, final valueName -> if (value instanceof PythonFail) {
        throw new RuntimeException("${valueName} could not be determined. Python FAILED with exit code ${value.code}\n" +
                "Command: ${value.command}\n\n${value.error}\n")
    } }
} }


class PythonFail {

    final List command
    final int code
    final String error

    PythonFail(final List command, final int code, final String error) {
        this.command = command
        this.code = code
        this.error = error
    }

    boolean asBoolean() {
        return false
    }
}

final evaluatePythonCode = {
    final command = [project.ext.pythonExe, '-c', "print(${it})"]
    logger.info "Executing ${command}"

    final process = command.execute()
    final output = new StringWriter()
    final error = new StringWriter()

    process.waitForProcessOutput output, error
    if (process.exitValue() == 0) {
        return output.toString().trim()
    }

    final fail = new PythonFail(command, process.exitValue(), error.toString())
    logger.warn "Python FAILED with exit code ${fail.code}\n\n${fail.error}"
    return fail
}

ext {
    pythonProjectDir = file "${project.buildDir}/python-project"

    pythonExe = (project.pythonExe.trim() ? (Paths.get project.pythonExe)
            : (project.buildDir.toPath() resolve "python/${isWindows ? 'python.exe' : 'bin/python'}")) as String

    pythonDir = evaluatePythonCode "__import__('sys').prefix"
    pythonPath = evaluatePythonCode "__import__('os').pathsep.join(__import__('sys').path).strip(__import__('os').pathsep)"

    jepDir = evaluatePythonCode "__import__('os').path.dirname(__import__('importlib.util').util.find_spec('jep').origin)"
    jepVersion = evaluatePythonCode "__import__('pkg_resources').require('jep')[0].version"
}


repositories {
    mavenLocal()
    mavenCentral()

    maven {
        url = 'https://vaadin.com/nexus/content/repositories/vaadin-addons'
    }

    if (project.ext.jepDir) {
        flatDir {
            dirs project.ext.jepDir
        }
    }
}

dependencyManagement {
    imports {
        mavenBom "com.vaadin:vaadin-bom:${project.vaadinVersion}"
    }
}

dependencies {
    implementation 'com.vaadin:vaadin-spring-boot-starter'
    implementation 'org.springframework.boot:spring-boot-devtools' // for Java live reload / Vaadin development mode

    implementation 'com.storedobject.chart:so-charts:3.1.3'
    implementation 'com.vladsch.flexmark:flexmark:0.64.0'
    implementation 'de.f0rce:ace:3.4.2'
    // implementation 'org.vaadin.artur:a-vaadin-helper:1.9.0'

    // implementation 'javax.servlet:javax.servlet-api:4.0.1'
    implementation 'jakarta.servlet:jakarta.servlet-api:6.0.0'

    implementation 'com.pivovarit:throwing-function:1.5.1'
    implementation 'one.util:streamex:0.8.1'

    if (project.ext.jepDir && project.ext.jepVersion) {
        implementation (files "${project.ext.jepDir}/jep-${project.ext.jepVersion}.jar")
    }

    annotationProcessor 'org.projectlombok:lombok:1.18.26'
    compileOnly 'org.projectlombok:lombok:1.18.26'

    testAnnotationProcessor 'org.projectlombok:lombok:1.18.26'
    testCompileOnly 'org.projectlombok:lombok:1.18.26'

    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.9.0'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.9.0'
}


vaadin {
    nodeVersion = 'v18.16.0'
    // pnpmEnable = true
    requireHomeNodeExec = true
    // useGlobalPnpm = false
}


tasks.register 'processPythonCompanyonsPackage', {
    dependsOn processResources
    group 'companyons'

    it.doFirst {
        final pythonProjectInputDir = file "${project.rootDir}/src/main/python"
        final pythonProjectOutputDir = file "${project.ext.pythonProjectDir}"

        if (pythonProjectOutputDir.exists()) {
            pythonProjectOutputDir.deleteDir()
        }

        pythonProjectOutputDir.mkdir()
        pythonProjectInputDir.traverse {
            final outputPath = file "${pythonProjectOutputDir}/${pythonProjectInputDir.relativePath it}" toPath()
            if (it.isDirectory()) {
                Files.createDirectory outputPath

            } else {
                Files.copy it.toPath(), outputPath
            }
        }
    }
}

tasks.register 'uninstallPythonCompanyonsPackage', Exec, {
    group 'companyons'

    workingDir = project.ext.pythonProjectDir
    commandLine = [project.ext.pythonExe, '-m', 'pip', 'uninstall', '--yes', 'companyons']
}

tasks.register 'installPythonCompanyonsPackage', Exec, {
    dependsOn processPythonCompanyonsPackage
    dependsOn uninstallPythonCompanyonsPackage
    group 'companyons'

    workingDir = project.ext.pythonProjectDir
    commandLine = [project.ext.pythonExe, '-m', 'pip', 'install', '.']
}

bootRun.dependsOn installPythonCompanyonsPackage


tasks.register 'installPythonJediPackage', Exec, {
    group 'companyons'

    commandLine = [project.ext.pythonExe, '-m', 'pip', 'install', 'jedi']
}

bootRun.dependsOn installPythonJediPackage


tasks.register 'downloadPython', Download, {
    group 'companyons'

    /*  Adapted from https://github.com/michel-kraemer/gradle-download-task#readme
        */

    src isWindows ? minicondaDownloadUrl : null
    dest buildDir
    overwrite false
}

/*
task downloadPip(type: Download) {
}
*/

tasks.register 'installPython', Exec, {
    dependsOn downloadPython
    // dependsOn downloadPip
    group 'companyons'

    workingDir = project.buildDir

    final basePath = project.buildDir.toPath()
    commandLine = [(basePath.resolve minicondaInstaller), '/S', '/NoRegistry=1', "/D=${basePath.resolve 'python'}"]

    /*  Adapted from https://discuss.gradle.org/t/extracting-single-file-from-zip-using-gradle-task/30486/2
        */

    /*
    final downloadedPythonZip = buildDir.toPath() resolve pythonZip
    from zipTree(downloadedPythonZip)

    final pythonDir = ext.pythonDir = buildDir.toPath() resolve 'python'
    into pythonDir
    */
}


tasks.register 'installCondaPackages', Exec, {
    group 'companyons'

    final packages = project.condaPackages.split(/\s+/) findAll { it?.trim() } toList()
    commandLine = [project.ext.pythonExe, '-m', 'conda', 'install', '--yes'] + packages
}

tasks.register 'installPipPackages', Exec, {
    group 'companyons'

    final packages = project.pipPackages.split(/\s+/) findAll { it?.trim() } toList()
    commandLine = [project.ext.pythonExe, '-m', 'pip', 'install'] + packages
}

tasks.register 'installPythonPackages', {
    group 'companyons'

    if (project.condaPackages?.trim()) {
        dependsOn installCondaPackages
    }

    if (project.pipPackages?.trim()) {
        dependsOn installPipPackages
    }
}

bootRun.dependsOn installPythonPackages


tasks.register 'uninstallJep', Exec, {
    group 'companyons'

    commandLine = [project.ext.pythonExe, '-m', 'pip', 'uninstall', '--yes', 'jep']
}

tasks.register 'installJep', Exec, {
    dependsOn uninstallJep
    group 'companyons'

    workingDir = rootDir.toPath() resolve 'jep'
    commandLine = [project.ext.pythonExe, '-m', 'pip', 'install', '.']
}


tasks.withType Exec configureEach {
    environment 'JAVA_HOME', (System.getProperty 'java.home')

    onWindows {
        if (project.ext.pythonDir) {
            environment 'PATH', (String.join File.pathSeparator, [project.ext.pythonDir] + [
                    // where dependencies of native jep.dll are located
                    'bin',
                    'DLLs',
                    'Library/bin',
                    'Library/usr/bin',
                    'Scripts',

            ].collect { Paths.get project.ext.pythonDir, it toString() } + [(System.getenv 'PATH')])
        }
    }
}


tasks.withType JavaExec configureEach {
    systemProperty 'java.library.path', project.ext.jepDir // where native jep library is located

    onWindows {
        if (project.ext.pythonDir) {
            environment 'PATH', (String.join File.pathSeparator, [project.ext.pythonDir] + [
                    // where dependencies of native jep.dll are located
                    'bin',
                    'DLLs',
                    'Library/bin',
                    'Library/usr/bin',
                    'Scripts',

            ].collect { Paths.get project.ext.pythonDir, it toString() } + [(System.getenv 'PATH')])
        }
    }

    environment 'PYTHONHOME', project.ext.pythonDir
    environment 'PYTHONPATH', project.ext.pythonPath
}


test {
    useJUnitPlatform()
}


publishing {
    publications {
        maven MavenPublication, {
            from components.java
        }
    }
}