Convert to gradle plugin

build.gradle.kts

@@ -2,6 +2,8 @@ import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
     kotlin("jvm") version "1.2.51"
+    `kotlin-dsl`
+    id("java-gradle-plugin")
 }
 
 repositories {
@@ -24,3 +26,12 @@ dependencies {
 tasks.withType<KotlinCompile> {
     kotlinOptions.jvmTarget = "1.8"
 }
+
+gradlePlugin {
+    (plugins) {
+        "ecore2java-plugin" {
+            id = "ecore2java"
+            implementationClass = "ecore2java.Ecore2JavaPlugin"
+        }
+    }
+}

settings.gradle

-rootProject.name = 'ecore-to-java'
-

settings.gradle.kts

+rootProject.name = "ecore2java-gradle"
+

src/main/kotlin/ecore2java/Ecore2JavaGenerator.kt

+package ecore2java
+
+import org.eclipse.emf.codegen.ecore.generator.Generator
+import org.eclipse.emf.codegen.ecore.genmodel.GenModel
+import org.eclipse.emf.codegen.ecore.genmodel.GenModelPackage
+import org.eclipse.emf.codegen.ecore.genmodel.generator.GenBaseGeneratorAdapter
+import org.eclipse.emf.codegen.merge.java.JControlModel
+import org.eclipse.emf.common.util.BasicMonitor
+import org.eclipse.emf.common.util.Diagnostic
+import org.eclipse.emf.common.util.URI
+import org.eclipse.emf.ecore.resource.Resource
+import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl
+import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl
+import org.gradle.api.logging.Logger
+import java.io.ByteArrayOutputStream
+import java.io.File
+import java.io.PrintStream
+
+class Ecore2JavaGenerator(outputDir: File, logger: Logger) {
+    private val resourceSet = ResourceSetImpl().apply {
+        uriConverter.uriMap[URI.createURI("platform:/resource/")] = URI.createFileURI(outputDir.absolutePath + File.separator)
+    }
+
+    private val generator = object : Generator() {
+        override fun getJControlModel() = JControlModel()
+    }.apply {
+        adapterFactoryDescriptorRegistry.addDescriptor(GenModelPackage.eNS_URI, OnlyCodeGenModelGeneratorAdapterFactory.Descriptor)
+    }
+
+    private val monitor = Monitor(logger)
+
+    init {
+        GenModelPackage.eINSTANCE
+
+        Resource.Factory.Registry.INSTANCE.extensionToFactoryMap.let {
+            it["genmodel"] = XMIResourceFactoryImpl()
+            it["ecore"] = XMIResourceFactoryImpl()
+        }
+    }
+
+    fun generate(genModelFile: File) {
+        var oldErr: PrintStream? = System.err
+        try {
+            System.setErr(PrintStream(ByteArrayOutputStream()))
+        } catch (_: Throwable) {
+            oldErr = null
+        }
+
+        try {
+            val genModel = getGenModel(genModelFile)
+            generator.input = genModel
+            generator.generate(genModel, GenBaseGeneratorAdapter.MODEL_PROJECT_TYPE, monitor)
+        } finally {
+            if (oldErr != null) {
+                System.setErr(oldErr)
+            }
+        }
+    }
+
+    private fun getGenModel(file: File): GenModel {
+        val res = resourceSet.getResource(URI.createFileURI(file.absolutePath), true)
+
+        return (res.contents[0] as GenModel).apply {
+            modelDirectory = "."
+            setCanGenerate(true)
+        }
+    }
+
+
+    private class Monitor(private val logger: Logger) : BasicMonitor() {
+        override fun beginTask(name: String?, totalWork: Int) {
+            if (name != null && name.isNotEmpty()) {
+                log(">>> $name")
+            }
+        }
+
+        override fun setTaskName(name: String?) {
+            if (name != null && name.isNotEmpty()) {
+                log("<>> $name")
+            }
+        }
+
+        override fun subTask(name: String?) {
+            if (name != null && name.isNotEmpty()) {
+                log(">>  $name")
+            }
+        }
+
+        override fun setBlocked(reason: Diagnostic) {
+            super.setBlocked(reason)
+            log("#>  " + reason.message)
+        }
+
+        override fun clearBlocked() {
+            log("=>  " + blockedReason.message)
+            super.clearBlocked()
+        }
+
+        private fun log(msg: String) {
+            logger.info(msg)
+        }
+    }
+}

src/main/kotlin/ecore2java/Ecore2JavaPlugin.kt

+package ecore2java
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.plugins.JavaPlugin
+import org.gradle.api.plugins.JavaPluginConvention
+import org.gradle.kotlin.dsl.get
+import org.gradle.kotlin.dsl.task
+import org.gradle.kotlin.dsl.withConvention
+import java.io.File
+
+@Suppress("unused")
+open class Ecore2JavaPlugin : Plugin<Project> {
+    override fun apply(project: Project) {
+        project.pluginManager.apply(JavaPlugin::class.java)
+
+
+        val extension = project.extensions.create("ecore2java", Ecore2JavaPluginExtension::class.java, project)
+
+        if (extension.genModels.isPresent) {
+            project.task("generateEcore") {
+                extension.genModels.get().forEach { inputs.file(it) }
+                outputs.dir(extension.outputDir)
+
+                doFirst {
+                    val generator = Ecore2JavaGenerator(File(extension.outputDir), logger)
+
+                    extension.genModels.get()
+                            .map(::File)
+                            .forEach(generator::generate)
+                }
+            }
+
+            project.withConvention(JavaPluginConvention::class) { sourceSets["main"].java.srcDir(extension.outputDir) }
+        }
+    }
+}

src/main/kotlin/ecore2java/Ecore2JavaPluginExtension.kt

+package ecore2java
+
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.listProperty
+
+open class Ecore2JavaPluginExtension(project: Project) {
+    val genModels = project.objects.listProperty<String>()
+    var outputDir = "${project.buildDir}/generated-src/ecore/java"
+
+    fun genModel(genModelFile: String) = genModels.add(genModelFile)
+}

src/main/kotlin/fehnomenal/ecore2java/OnlyCodeGenModelGeneratorAdapterFactory.kt → src/main/kotlin/ecore2java/OnlyCodeGenModelGeneratorAdapterFactory.kt

-package fehnomenal.ecore2java
+package ecore2java
 
 import org.eclipse.emf.codegen.ecore.generator.GeneratorAdapterFactory
 import org.eclipse.emf.codegen.ecore.genmodel.GenModel

src/main/kotlin/fehnomenal/ecore2java/Main.kt

-package fehnomenal.ecore2java
-
-import org.eclipse.emf.codegen.ecore.generator.Generator
-import org.eclipse.emf.codegen.ecore.genmodel.GenModel
-import org.eclipse.emf.codegen.ecore.genmodel.GenModelPackage
-import org.eclipse.emf.codegen.ecore.genmodel.generator.GenBaseGeneratorAdapter
-import org.eclipse.emf.codegen.merge.java.JControlModel
-import org.eclipse.emf.common.util.BasicMonitor
-import org.eclipse.emf.common.util.URI
-import org.eclipse.emf.ecore.resource.Resource
-import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl
-import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl
-import java.io.File
-
-fun main(args: Array<String>) {
-    GenModelPackage.eINSTANCE
-
-    Resource.Factory.Registry.INSTANCE.extensionToFactoryMap.let {
-        it["genmodel"] = XMIResourceFactoryImpl()
-        it["ecore"] = XMIResourceFactoryImpl()
-    }
-
-    generate(File(args[0]), File(args[1]))
-}
-
-private fun generate(genModelFile: File, targetFolder: File) {
-    val genModel = ResourceSetImpl().run {
-        uriConverter.uriMap[URI.createURI("platform:/resource/")] = URI.createFileURI(targetFolder.absolutePath + File.separator)
-
-        val rs = getResource(URI.createFileURI(genModelFile.absolutePath), true)
-        (rs.contents[0] as GenModel).apply {
-            modelDirectory = "."
-            setCanGenerate(true)
-        }
-    }
-
-    val generator = object : Generator() {
-        override fun getJControlModel() = JControlModel()
-    }
-    generator.adapterFactoryDescriptorRegistry.addDescriptor(GenModelPackage.eNS_URI, OnlyCodeGenModelGeneratorAdapterFactory.Descriptor)
-    generator.input = genModel
-    generator.generate(genModel, GenBaseGeneratorAdapter.MODEL_PROJECT_TYPE, BasicMonitor.Printing(System.out))
-}