build.gradle

group 'asmble'
version '0.2.0'

buildscript {
    ext.kotlin_version = '1.2.61'
    ext.asm_version = '6.2.1'

    repositories {
        mavenCentral()
        maven {
            url "https://plugins.gradle.org/m2/"
        }
    }
    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
        classpath 'me.champeau.gradle:jmh-gradle-plugin:0.4.5'
        classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.8.4'
    }
}

allprojects {
    apply plugin: 'java'
    group 'com.github.cretz.asmble'
    version '0.4.11-fl'

    // skips building and running for the specified examples
    ext.skipExamples = ['c-simple', 'go-simple', 'rust-regex']
    // todo disabling Rust regex is temporary because some strings in wasm code exceed the size in 65353 bytes.

    repositories {
        mavenCentral()
    }
}

project(':annotations') {
    javadoc {
        options.links 'https://docs.oracle.com/javase/8/docs/api/'
        // TODO: change when https://github.com/gradle/gradle/issues/2354 is fixed
        options.addStringOption 'Xdoclint:all', '-Xdoclint:-missing'
    }

    publishSettings(project, 'asmble-annotations', 'Asmble WASM Annotations')
}

project(':compiler') {
    apply plugin: 'kotlin'
    apply plugin: 'application'

    applicationName = "asmble"
    mainClassName = "asmble.cli.MainKt"

    distTar.archiveName = 'asmble.tar'
    distZip.archiveName = 'asmble.zip'

    dependencies {
        compile project(':annotations')
        compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
        compile "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"
        compile "org.ow2.asm:asm-tree:$asm_version"
        compile "org.ow2.asm:asm-util:$asm_version"
        compile "org.ow2.asm:asm-commons:$asm_version"
        testCompile 'junit:junit:4.12'
        testCompile "org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version"
    }

    publishSettings(project, 'asmble-compiler', 'Asmble WASM Compiler')
}

project(':examples') {
    subprojects {
        dependencies {
            compileOnly project(':compiler')
        }
        
        // C/C++ example helpers

        task cToWasm {
            doFirst {
                mkdir 'build'
                exec {
                    def cFileName = fileTree(dir: 'src', includes: ['*.c']).files.iterator().next()
                    commandLine 'clang', '--target=wasm32-unknown-unknown-wasm', '-O3', cFileName, '-c', '-o', 'build/lib.wasm'
                }
            }
        }

        task showCWast(type: JavaExec) {
            dependsOn cToWasm
            classpath configurations.compileClasspath
            main = 'asmble.cli.MainKt'
            doFirst {
                args 'translate', 'build/lib.wasm'
            }
        }

        task compileCWasm(type: JavaExec) {
            dependsOn cToWasm
            classpath configurations.compileClasspath
            main = 'asmble.cli.MainKt'
            doFirst {
                def outFile = 'build/wasm-classes/' + wasmCompiledClassName.replace('.', '/') + '.class'
                file(outFile).parentFile.mkdirs()
                args 'compile', 'build/lib.wasm', wasmCompiledClassName, '-out', outFile
            }
        }

        // Go example helpers

        task goToWasm {
            doFirst {
                mkdir 'build'
                exec {
                    def goFileName = fileTree(dir: '.', includes: ['*.go']).files.iterator().next()
                    environment 'GOOS': 'js', 'GOARCH': 'wasm'
                    commandLine 'go', 'build', '-o', 'build/lib.wasm', goFileName
                }
            }
        }

        task compileGoWasm(type: JavaExec) {
            dependsOn goToWasm
            classpath configurations.compileClasspath
            main = 'asmble.cli.MainKt'
            doFirst {
                // args 'help', 'compile'
                def outFile = 'build/wasm-classes/' + wasmCompiledClassName.replace('.', '/') + '.class'
                file(outFile).parentFile.mkdirs()
                args 'compile', 'build/lib.wasm', wasmCompiledClassName, '-out', outFile, '-log', 'debug'
            }
        }

        // Rust example helpers

        ext.rustBuildRelease = true

        task rustToWasm(type: Exec) {
            if (rustBuildRelease) {
                commandLine 'cargo', 'build', '--release'
            } else {
                commandLine 'cargo', 'build'
            }
        }

        ext.rustWasmFileName = { ->
            def buildType = rustBuildRelease ? 'release' : 'debug'
            def wasmFiles = fileTree(dir: "target/wasm32-unknown-unknown/$buildType", includes: ['*.wasm']).files
            if (wasmFiles.size() != 1) throw new GradleException('Expected single WASM file, got ' + wasmFiles.size())
            return wasmFiles.iterator().next()
        }

        task rustWasmFile() {
            dependsOn rustToWasm
            doFirst {
                println 'File: ' + rustWasmFileName()
            }
        }

        task showRustWast(type: JavaExec) {
            dependsOn rustToWasm
            classpath configurations.compileClasspath
            main = 'asmble.cli.MainKt'
            doFirst {
                args 'translate', rustWasmFileName()
            }
        }

        task compileRustWasm(type: JavaExec) {
            dependsOn rustToWasm
            classpath configurations.compileClasspath
            main = 'asmble.cli.MainKt'
            doFirst {
                // args 'help', 'compile'
                def outFile = 'build/wasm-classes/' + wasmCompiledClassName.replace('.', '/') + '.class'
                file(outFile).parentFile.mkdirs()
                args 'compile', rustWasmFileName(), wasmCompiledClassName, '-out', outFile
            }
        }
    }
}

project(':examples:c-simple') {
    if (project.name in skipExamples) {
        println("[Note!] Building and runnig for ${project.name} was skipped")
        test.onlyIf { false } // explicit skipping tests
        compileJava.onlyIf { false } // explicit skipping compile
        return
    }

    apply plugin: 'application'
    ext.wasmCompiledClassName = 'asmble.generated.CSimple'
    dependencies {
        compile files('build/wasm-classes')
    }

    compileJava {
        dependsOn compileCWasm
    }
    mainClassName = 'asmble.examples.csimple.Main'
}

project(':examples:go-simple') {
    if (project.name in skipExamples) {
        println("[Note!] Building and runnig for ${project.name} was skipped")
        test.onlyIf { false } // explicit skipping tests
        compileJava.onlyIf { false } // explicit skipping compile
        return
    }
    apply plugin: 'application'
    ext.wasmCompiledClassName = 'asmble.generated.GoSimple'
    dependencies {
        compile files('build/wasm-classes')
    }
    compileJava {
        dependsOn compileGoWasm
    }
    mainClassName = 'asmble.examples.gosimple.Main'
}

 project(':examples:rust-regex') {
     if (project.name in skipExamples) {
         println("[Note!] Building and runnig for ${project.name} was skipped")
         test.onlyIf { false } // explicit skipping tests
         compileJava.onlyIf { false } // explicit skipping compile
         compileTestJava.onlyIf { false } // explicit skipping compile
         return
     }
     apply plugin: 'application'
     apply plugin: 'me.champeau.gradle.jmh'
     ext.wasmCompiledClassName = 'asmble.generated.RustRegex'
     dependencies {
         compile files('build/wasm-classes')
         testCompile 'junit:junit:4.12'
     }
     compileJava {
         dependsOn compileRustWasm
     }
     mainClassName = 'asmble.examples.rustregex.Main'

     test {
         testLogging.showStandardStreams = true
         testLogging.events 'PASSED', 'SKIPPED'
     }
     jmh {
         iterations = 5
         warmupIterations = 5
         fork = 3
     }
 }

project(':examples:rust-simple') {
    if (project.name in skipExamples) {
        println("[Note!] Building and runnig for ${project.name} was skipped")
        test.onlyIf { false } // explicit skipping tests
        compileJava.onlyIf { false } // explicit skipping compile
        return
    }
    apply plugin: 'application'
    ext.wasmCompiledClassName = 'asmble.generated.RustSimple'
    dependencies {
        compile files('build/wasm-classes')
    }
    compileJava {
        dependsOn compileRustWasm
    }
    mainClassName = 'asmble.examples.rustsimple.Main'
}

project(':examples:rust-string') {
    if (project.name in skipExamples) {
        println("[Note!] Building and runnig for ${project.name} was skipped")
        test.onlyIf { false } // explicit skipping tests
        compileJava.onlyIf { false } // explicit skipping compile
        return
    }
    apply plugin: 'application'
    ext.wasmCompiledClassName = 'asmble.generated.RustString'
    dependencies {
        compile files('build/wasm-classes')
    }
    compileJava {
        dependsOn compileRustWasm
    }
    mainClassName = 'asmble.examples.ruststring.Main'
}

def publishSettings(project, projectName, projectDescription) {

    project.with {
        apply plugin: 'com.jfrog.bintray'
        apply plugin: 'maven-publish'
        apply plugin: 'maven'


        task sourcesJar(type: Jar) {
            from sourceSets.main.allJava
            classifier = 'sources'
        }

        publishing {
            publications {
                MyPublication(MavenPublication) {
                    from components.java
                    groupId group
                    artifactId projectName
                    artifact sourcesJar
                    version version
                }
            }
        }

        bintray {
            if(!hasProperty("bintrayUser") || !hasProperty("bintrayKey")) {
                return
            }

            user = bintrayUser
            key =  bintrayKey
            publications = ['MyPublication']
            //[Default: false] Whether to override version artifacts already published
            override = false
            //[Default: false] Whether version should be auto published after an upload
            publish = true
            
            pkg {
                repo = 'releases'
                name = projectName
                userOrg =  'fluencelabs'
                licenses = ['MIT']
                vcsUrl = 'https://github.com/fluencelabs/asmble'
                version {
                    name = project.version
                    desc = projectDescription
                    released  = new Date()
                    vcsTag = project.version
                }
            }
            
        }
    }

}