build.gradle

buildscript {
    repositories {
//        mavenLocal()
        mavenCentral()
        maven {
            url "https://plugins.gradle.org/m2/"
        }
        maven {
            name "mule-releases"
            url "https://repository.mulesoft.org/nexus/content/repositories/releases/"
        }
        maven {
            name "mule-snapshots"
            url "https://repository.mulesoft.org/nexus/content/repositories/snapshots/"
        }
    }
    dependencies {
        classpath "org.mule.weave:weave-gradle-plugin:" + weavedocVersion
        classpath "com.monochromeroad.gradle-plugins:gradle-aws-s3-sync:0.10"
        classpath group: 'org.mule.weave', name: 'runtime', version: weaveVersion
        classpath group: 'org.mule.weave', name: 'core-modules', version: weaveVersion
        classpath group: 'org.mule.weave', name: 'java-module', version: weaveVersion
        classpath group: 'org.mule.weave', name: 'yaml-module', version: weaveVersion
        classpath group: 'org.mule.weave', name: 'file-module', version: fileModuleVersion
    }
}

apply plugin: 'java'
apply plugin: 'dataweave'
group = "org.mule.weave"
version = "0.0.1-SNAPSHOT"

repositories {
    // mavenLocal()
    mavenCentral()
    maven {
        name "mule-releases"
        url "https://repository.mulesoft.org/nexus/content/repositories/releases/"
    }
    maven {
        name "mule-snapshots"
        url "https://repository.mulesoft.org/nexus/content/repositories/snapshots/"
    }
}

dependencies {
    testCompile group: 'org.mule.weave', name: 'runtime', version: weaveVersion
    testCompile group: 'org.mule.weave', name: 'core-modules', version: weaveVersion
    testCompile group: 'org.mule.weave', name: 'java-module', version: weaveVersion

    testCompile group: 'org.mule.weave', name: 'data-weave-testing-framework', version: wtfVersion
    testCompile group: 'org.mule.weave', name: 'yaml-module', version: weaveVersion
}

task docs(type: Zip) {
    from 'src/main/docs/'
}


ext {
    aws = [
            accessKey: System.getenv("AWS_ACCESS_KEY_ID"),
            secretKey: System.getenv("AWS_SECRET_KEY")
    ]
}

import com.monochromeroad.gradle.plugin.aws.s3.S3Sync
import org.mule.weave.v2.completion.DataFormatDescriptor$
import org.mule.weave.v2.completion.DataFormatProperty
import org.mule.weave.v2.editor.*
import org.mule.weave.v2.model.EmptyWeaveServicesProvider$
import org.mule.weave.v2.model.ServiceManager$
import org.mule.weave.v2.runtime.DataWeaveScriptingEngine
import org.mule.weave.v2.runtime.ScriptingBindings
import org.mule.weave.v2.ts.WeaveType
import scala.None$
import scala.Some

task packageDistribution(type: Zip) {
    classifier = "content"
    from "$buildDir/distributions/content"
}

task tutorialContentToJson(type: TutorialContentToJsonTask)


docs.dependsOn(weavetest)
build.dependsOn(docs)
build.dependsOn(tutorialContentToJson)
packageDistribution.dependsOn(tutorialContentToJson)
build.dependsOn(packageDistribution)

class WeaveTypeFactory {
    static def dataFormats() {
        def dfd = DataFormatDescriptor$.MODULE$
        DataFormatProperty[] dfp = []
        def dataFormats = [
                dfd.apply("application/dw", "weave", dfp, dfp)
        ]
        dataFormats
    }

    static def parse(String content) {
        VirtualFileSystem fs = EmptyVirtualFileSystem$.MODULE$
        fs.updateContent("/dummy.dwl", content)
        def file = fs.file("/dummy.dwl")
        def service = new WeaveToolingService(fs, {dataFormats()})
        ImplicitInput inputs = ImplicitInput$.MODULE$.apply()
        scala.Option<WeaveType> none = None$.MODULE$
        def document = service.openInMemory(file, inputs, none)
        document.typeOfMapping().get()
    }
}

class TutorialContentToJsonTask extends DefaultTask {
    @TaskAction
    def run() {
        def oldUserDir = System.getProperty("user.dir")
        try {
            //Change to user dir that is expected on the scripts
            System.setProperty("user.dir", "$project.projectDir")
            def engine = new DataWeaveScriptingEngine()
            def compile = engine.compile(new File("$project.projectDir/scripts/transform.dwl"))
            def serviceManager = ServiceManager$.MODULE$.apply(org.mule.weave.v2.model.service.StdOutputLoggingService$.MODULE$)
            def outputFolder = new File("$project.buildDir/distributions/content/")
            outputFolder.mkdirs()
            def outputFile = new File(outputFolder, "tutorial_content.json")
            compile.write(new ScriptingBindings(), serviceManager, Some.apply(outputFile))

            def compile2 = engine.compile(new File("$project.projectDir/scripts/weaveTypes.dwl"))
            def bindings = new ScriptingBindings().addBinding("payload", outputFile, "application/json")
            Map<String, Map<String, String>> types = compile2.write(bindings, serviceManager).content
            String contentStr = typesToJson(types)
            def outputFile3 = new File(outputFolder, "weaveTypes.json")
            outputFile3.write contentStr
        } finally {
            System.setProperty("user.dir", oldUserDir)
        }
    }

    private static String typesToJson(Map<String, Map<String, String>> types) {
        def builder = new StringBuilder()
        def initialStr = "{\n"
        builder.append(initialStr)
        types.entrySet().forEach { entry ->
            def path = entry.getKey()
            def inputs = entry.getValue()
            if (builder.length() > initialStr.length()) {
                builder.append(",\n")
            }
            builder.append('  "').append(path).append('": {\n')
            def inputsBuilder = new StringBuilder()
            inputs.entrySet().forEach { it ->
                if (inputsBuilder.length() > 0) {
                    inputsBuilder.append(",\n")
                }
                def inputName = it.getKey()
                def content = it.getValue()
                def weaveType = WeaveTypeFactory.parse(content)
                inputsBuilder.append('    "').append(inputName).append('": "').append(weaveType.toString().replaceAll('"', "'").replaceAll("\n", "")).append('"')
            }
            builder.append(inputsBuilder.toString())
            builder.append("\n  }")
        }
        builder.append("\n}")
        def contentStr = builder.toString()
        contentStr
    }
}