refactor languages <> scripts

Author: rcannood

src/main/scala/io/viash/config/Config.scala

@@ -612,7 +612,8 @@ object Config extends Logging {
       val yaml = header.map(s => s.drop(3)).mkString("\n")
       val code = body.mkString("\n")
 
-      val script = Script(dest = Some(basename), text = Some(code), `type` = scriptObj.`type`)
+      val scriptType = s"${scriptObj.id}_script"
+      val script = Script(dest = Some(basename), text = Some(code), `type` = scriptType)
 
       (yaml, Some(script))
     } else {

src/main/scala/io/viash/config/resources/BashScript.scala

@@ -24,6 +24,7 @@ import io.viash.schemas._
 import java.net.URI
 import io.viash.helpers.Bash
 import io.viash.config.Config
+import io.viash.languages.{Bash => BashLang}
 
 @description("""An executable Bash script.
                |When defined in resources, only the first entry will be executed when running the built component or when running `viash run`.
@@ -37,19 +38,20 @@ case class BashScript(
   parent: Option[URI] = None,
 
   @description("Specifies the resource as a Bash script.")
-  `type`: String = BashScript.`type`
+  `type`: String = "bash_script"
 ) extends Script {
-  val companion = BashScript
+  val language = BashLang
   def copyResource(path: Option[String], text: Option[String], dest: Option[String], is_executable: Option[Boolean], parent: Option[URI]): Resource = {
     copy(path = path, text = text, dest = dest, is_executable = is_executable, parent = parent)
   }
 
   def generateInjectionMods(argsMetaAndDeps: Map[String, List[Argument[_]]], config: Config): ScriptInjectionMods = {
 
-    val fullCode = s"""${language.viashParseYamlCode}
+    val fullCode = s"""${language.viashParseJsonCode}
 
-_viash_yaml_content=$$(cat)
-ViashParseYamlBash <<< "$$_viash_yaml_content"
+# Parse JSON parameters
+_viash_json_content=$$(cat "$$VIASH_WORK_PARAMS")
+ViashParseJsonBash <<< "$$_viash_json_content"
 
 """
     ScriptInjectionMods(params = fullCode)

src/main/scala/io/viash/config/resources/CSharpScript.scala

@@ -24,6 +24,7 @@ import io.viash.schemas._
 import java.net.URI
 import io.viash.helpers.Bash
 import io.viash.config.Config
+import io.viash.languages.CSharp
 
 @description("""An executable C# script.
                |When defined in resources, only the first entry will be executed when running the built component or when running `viash run`.
@@ -37,26 +38,25 @@ case class CSharpScript(
   parent: Option[URI] = None,
 
   @description("Specifies the resource as a C# script.")
-  `type`: String = CSharpScript.`type`
+  `type`: String = "csharp_script"
 ) extends Script {
-  val companion = CSharpScript
+  val language = CSharp
   def copyResource(path: Option[String], text: Option[String], dest: Option[String], is_executable: Option[Boolean], parent: Option[URI]): Resource = {
     copy(path = path, text = text, dest = dest, is_executable = is_executable, parent = parent)
   }
 
   def generateInjectionMods(argsMetaAndDeps: Map[String, List[Argument[_]]], config: Config): ScriptInjectionMods = {
     // Extract only the class and functions, not the main execution part
-    // TODO: remove takewhile
-    val helperFunctions = language.viashParseYamlCode
+    val helperFunctions = language.viashParseJsonCode
       .split("\n")
       .takeWhile(line => !line.contains("if (Args.Length == 0)"))
       .mkString("\n")
 
     val paramsCode = if (argsMetaAndDeps.nonEmpty) {
-      // Parse YAML once and extract all sections
-      val parseOnce = "// Parse YAML parameters once and extract all sections\nvar _viashYamlData = ViashYamlParser.ParseYaml();\n"
+      // Parse JSON once and extract all sections
+      val parseOnce = "// Parse JSON parameters once and extract all sections\nvar _viashJsonData = ViashJsonParser.ParseJson();\n"
       val extractSections = argsMetaAndDeps.map { case (dest, _) =>
-        s"var $dest = _viashYamlData.ContainsKey(\"$dest\") ? (Dictionary<string, object>)_viashYamlData[\"$dest\"] : new Dictionary<string, object>();"
+        s"var $dest = _viashJsonData.ContainsKey(\"$dest\") ? (Dictionary<string, object>)_viashJsonData[\"$dest\"] : new Dictionary<string, object>();"
       }.mkString("\n")
 
       parseOnce + extractSections

src/main/scala/io/viash/config/resources/Executable.scala

@@ -22,6 +22,7 @@ import java.nio.file.Path
 import io.viash.config.arguments.Argument
 import io.viash.schemas._
 import io.viash.config.Config
+import io.viash.languages.Language
 
 @description("An executable file.")
 @subclass("executable")
@@ -35,7 +36,7 @@ case class Executable(
   @description("Specifies the resource as an executable.")
   `type`: String = "executable"
 ) extends Script {
-  val companion = Executable
+  val language: Language = null // todo: deprecate executable
   def copyResource(path: Option[String], text: Option[String], dest: Option[String], is_executable: Option[Boolean], parent: Option[URI]): Resource = {
     copy(path = path, text = text, dest = dest, is_executable = is_executable, parent = parent)
   }

src/main/scala/io/viash/config/resources/JavaScriptScript.scala

@@ -24,6 +24,7 @@ import java.net.URI
 import io.viash.helpers.Bash
 import io.viash.config.Config
 import io.viash.config.arguments.{Argument, StringArgument, IntegerArgument, BooleanArgumentBase, LongArgument, DoubleArgument, FileArgument}
+import io.viash.languages.JavaScript
 
 @description("""An executable JavaScript script.
                |When defined in resources, only the first entry will be executed when running the built component or when running `viash run`.
@@ -37,27 +38,26 @@ case class JavaScriptScript(
   parent: Option[URI] = None,
 
   @description("Specifies the resource as a JavaScript script.")
-  `type`: String = JavaScriptScript.`type`
+  `type`: String = "javascript_script"
 ) extends Script {
-  val companion = JavaScriptScript
+  val language = JavaScript
   def copyResource(path: Option[String], text: Option[String], dest: Option[String], is_executable: Option[Boolean], parent: Option[URI]): Resource = {
     copy(path = path, text = text, dest = dest, is_executable = is_executable, parent = parent)
   }
 
   def generateInjectionMods(argsMetaAndDeps: Map[String, List[Argument[_]]], config: Config): ScriptInjectionMods = {
     // Extract only the functions, not the main execution part or module exports
-    // TODO: remove this part
-    val helperFunctions = language.viashParseYamlCode
+    val helperFunctions = language.viashParseJsonCode
       .split("\n")
       .takeWhile(line => !line.contains("if (require.main === module)"))
-      .filterNot(line => line.contains("if (typeof module !== 'undefined' && module.exports)"))
+      .filterNot(line => line.contains("module.exports"))
       .mkString("\n")
 
     val paramsCode = if (argsMetaAndDeps.nonEmpty) {
-      // Parse YAML once and extract all sections
-      val parseOnce = "// Parse YAML parameters once and extract all sections\nlet _viashYamlData = viashParseYaml();\n"
+      // Parse JSON once and extract all sections
+      val parseOnce = "// Parse JSON parameters once and extract all sections\nconst _viashJsonData = viashParseJson();\n"
       val extractSections = argsMetaAndDeps.map { case (dest, _) =>
-        s"let $dest = _viashYamlData['$dest'] || {};"
+        s"const $dest = _viashJsonData['$dest'] || {};"
       }.mkString("\n")
 
       parseOnce + extractSections

src/main/scala/io/viash/config/resources/NextflowScript.scala

@@ -29,6 +29,7 @@ import io.circe.syntax._
 import io.viash.helpers.circe._
 import io.viash.ViashNamespace
 import io.viash.config.dependencies.Dependency
+import io.viash.languages.Nextflow
 
 @description("""A Nextflow script. Work in progress; added mainly for annotation at the moment.""")
 @subclass("nextflow_script")
@@ -43,10 +44,10 @@ case class NextflowScript(
   entrypoint: String,
 
   @description("Specifies the resource as a Nextflow script.")
-  `type`: String = NextflowScript.`type`
+  `type`: String = "nextflow_script"
 ) extends Script {
 
-  val companion = NextflowScript
+  val language = Nextflow
 
   def copyResource(path: Option[String], text: Option[String], dest: Option[String], is_executable: Option[Boolean], parent: Option[URI]): Resource = {
     copy(path = path, text = text, dest = dest, is_executable = is_executable, parent = parent)

src/main/scala/io/viash/config/resources/PythonScript.scala

@@ -24,6 +24,7 @@ import java.net.URI
 import _root_.io.viash.helpers.Bash
 import io.viash.schemas._
 import io.viash.config.Config
+import io.viash.languages.Python
 
 @description("""An executable Python script.
                |When defined in resources, only the first entry will be executed when running the built component or when running `viash run`.
@@ -37,25 +38,25 @@ case class PythonScript(
   parent: Option[URI] = None,
 
   @description("Specifies the resource as a Python script.")
-  `type`: String = PythonScript.`type`
+  `type`: String = "python_script"
 ) extends Script {
-  val companion = PythonScript
+  val language = Python
   def copyResource(path: Option[String], text: Option[String], dest: Option[String], is_executable: Option[Boolean], parent: Option[URI]): Resource = {
     copy(path = path, text = text, dest = dest, is_executable = is_executable, parent = parent)
   }
 
   def generateInjectionMods(argsMetaAndDeps: Map[String, List[Argument[_]]], config: Config): ScriptInjectionMods = {
     // Extract only the functions, not the main execution part
-    val helperFunctions = language.viashParseYamlCode
+    val helperFunctions = language.viashParseJsonCode
       .split("\n")
       .takeWhile(line => !line.startsWith("if __name__ == \"__main__\":"))
       .mkString("\n")
 
     val paramsCode = if (argsMetaAndDeps.nonEmpty) {
-      // Parse YAML once and extract all sections
-      val parseOnce = "# Parse YAML parameters once and extract all sections\n_viash_yaml_data = viash_parse_yaml()\n"
+      // Parse JSON once and extract all sections
+      val parseOnce = "# Parse JSON parameters once and extract all sections\n_viash_json_data = viash_parse_json()\n"
       val extractSections = argsMetaAndDeps.map { case (dest, _) =>
-        s"$dest = _viash_yaml_data.get('$dest', {})"
+        s"$dest = _viash_json_data.get('$dest', {})"
       }.mkString("\n")
 
       parseOnce + extractSections

src/main/scala/io/viash/config/resources/RScript.scala

@@ -24,6 +24,7 @@ import io.viash.schemas._
 
 import java.net.URI
 import io.viash.config.Config
+import io.viash.languages.R
 
 @description("""An executable R script.
                |When defined in resources, only the first entry will be executed when running the built component or when running `viash run`.
@@ -37,25 +38,25 @@ case class RScript(
   parent: Option[URI] = None,
 
   @description("Specifies the resource as a R script.")
-  `type`: String = RScript.`type`
+  `type`: String = "r_script"
 ) extends Script {
-  val companion = RScript
+  val language = R
   def copyResource(path: Option[String], text: Option[String], dest: Option[String], is_executable: Option[Boolean], parent: Option[URI]): Resource = {
     copy(path = path, text = text, dest = dest, is_executable = is_executable, parent = parent)
   }
 
   def generateInjectionMods(argsMetaAndDeps: Map[String, List[Argument[_]]], config: Config): ScriptInjectionMods = {
     // Extract only the functions, not the main execution part  
-    val helperFunctions = language.viashParseYamlCode
+    val helperFunctions = language.viashParseJsonCode
       .split("\n")
       .takeWhile(line => !line.contains("if (!interactive() && identical(environment(), globalenv()))"))
       .mkString("\n")
 
     val paramsCode = if (argsMetaAndDeps.nonEmpty) {
-      // Parse YAML once and extract all sections
-      val parseOnce = "# Parse YAML parameters once and extract all sections\n.viash_yaml_data <- viash_parse_yaml()\n"
+      // Parse JSON once and extract all sections
+      val parseOnce = "# Parse JSON parameters once and extract all sections\n.viash_json_data <- viash_parse_json()\n"
       val extractSections = argsMetaAndDeps.map { case (dest, _) =>
-        s"$dest <- if (is.null(.viash_yaml_data[['$dest']])) list() else .viash_yaml_data[['$dest']]"
+        s"$dest <- if (is.null(.viash_json_data[['$dest']])) list() else .viash_json_data[['$dest']]"
       }.mkString("\n")
 
       parseOnce + extractSections
@@ -73,7 +74,7 @@ case class RScript(
        |# restore original warn setting
        |options(.viash_orig_warn)
        |rm(.viash_orig_warn)
-       |rm(.viash_yaml_data)
+       |rm(.viash_json_data)
        |""".stripMargin
     ScriptInjectionMods(params = outCode)
   }

src/main/scala/io/viash/config/resources/ScalaScript.scala

@@ -24,6 +24,7 @@ import io.viash.schemas._
 import java.net.URI
 import io.viash.helpers.Bash
 import io.viash.config.Config
+import io.viash.languages.{Scala => ScalaLang}
 
 @description("""An executable Scala script.
                |When defined in resources, only the first entry will be executed when running the built component or when running `viash run`.
@@ -37,25 +38,25 @@ case class ScalaScript(
   parent: Option[URI] = None,
 
   @description("Specifies the resource as a Scala script.")
-  `type`: String = ScalaScript.`type`
+  `type`: String = "scala_script"
 ) extends Script {
-  val companion = ScalaScript
+  val language = ScalaLang
   def copyResource(path: Option[String], text: Option[String], dest: Option[String], is_executable: Option[Boolean], parent: Option[URI]): Resource = {
     copy(path = path, text = text, dest = dest, is_executable = is_executable, parent = parent)
   }
 
   def generateInjectionMods(argsMetaAndDeps: Map[String, List[Argument[_]]], config: Config): ScriptInjectionMods = {
     // Extract only the object and functions, not the main execution part
-    val helperFunctions = language.viashParseYamlCode
+    val helperFunctions = language.viashParseJsonCode
       .split("\n")
       .takeWhile(line => !line.contains("if (sys.props.get(\"viash.run.main\").contains(\"true\")"))
       .mkString("\n")
 
     val paramsCode = if (argsMetaAndDeps.nonEmpty) {
-      // Parse YAML once and extract all sections
-      val parseOnce = "// Parse YAML parameters once and extract all sections\nval _viashYamlData = ViashYamlParser.parseYaml()\n"
+      // Parse JSON once and extract all sections
+      val parseOnce = "// Parse JSON parameters once and extract all sections\nval _viashJsonData = ViashJsonParser.parseJson()\n"
       val extractSections = argsMetaAndDeps.map { case (dest, _) =>
-        s"val $dest = _viashYamlData.getOrElse(\"$dest\", Map.empty[String, Any])"
+        s"val $dest = _viashJsonData.getOrElse(\"$dest\", Map.empty[String, Any])"
       }.mkString("\n")
 
       parseOnce + extractSections

src/main/scala/io/viash/config/resources/Script.scala

@@ -20,7 +20,8 @@ package io.viash.config.resources
 import java.net.URI
 import io.viash.config.arguments.Argument
 import io.viash.config.Config
-import io.viash.language.Language
+import io.viash.languages.Language
+import io.viash.languages.{Bash, Python, R, JavaScript, Nextflow, Scala, CSharp}
 
 trait Script extends Resource {
   val language: Language
@@ -37,7 +38,7 @@ trait Script extends Resource {
     val mods = generateInjectionMods(argsMetaAndDeps, config)
 
     val viashLines = Array(
-      companion.commentStr + " The following code has been auto-generated by Viash.",
+      language.commentStr + " The following code has been auto-generated by Viash.",
       mods.params
     )
 
@@ -55,9 +56,9 @@ trait Script extends Resource {
         viashLinesWDelimiter ++ 
         lines.slice(endIndex, lines.length)
       } else {
-        Array(companion.commentStr + companion.commentStr + " VIASH START") ++
+        Array(language.commentStr + language.commentStr + " VIASH START") ++
         viashLines ++ 
-        Array(companion.commentStr + companion.commentStr + " VIASH END") ++
+        Array(language.commentStr + language.commentStr + " VIASH END") ++
         lines
       }
     val li2 = 
@@ -82,15 +83,15 @@ trait Script extends Resource {
     li.mkString("\n")
   }
 
-  def command(script: String): String = (companion.executor :+ s"\"$script\"").mkString(" ")
-  def commandSeq(script: String): Seq[String] = companion.executor ++ Seq(script)
+  def command(script: String): String = (language.executor :+ s"\"$script\"").mkString(" ")
+  def commandSeq(script: String): Seq[String] = language.executor ++ Seq(script)
 }
 
 object Script {
   val languages = List(Bash, Python, R, JavaScript, Nextflow, Scala, CSharp)
   val extensions =
     languages
-      .map(x => (x.extension.toLowerCase, x))
+      .flatMap(lang => lang.extensions.map(ext => (ext.toLowerCase, lang)))
       .toMap
 
   def fromExt(extension: String): Language = {
@@ -106,25 +107,26 @@ object Script {
     entrypoint: Option[String] = None,
     `type`: String
   ): Script = {
+    val languageId = `type`.replaceAll("_script$", "")
 
-    if (`type` != NextflowScript.`type`)
+    if (languageId != Nextflow.id)
       assert(entrypoint.isEmpty, message = s"Entrypoints are not (yet) supported for resources of type ${`type`}.")
 
-    `type` match {
-      case BashScript.`type` =>
+    languageId match {
+      case Bash.id =>
         BashScript(path = path, text = text, dest = dest, is_executable = is_executable, parent = parent)
-      case CSharpScript.`type` =>
+      case CSharp.id =>
         CSharpScript(path = path, text = text, dest = dest, is_executable = is_executable, parent = parent)
-      case JavaScriptScript.`type` =>
+      case JavaScript.id =>
         JavaScriptScript(path = path, text = text, dest = dest, is_executable = is_executable, parent = parent)
-      case NextflowScript.`type` =>
+      case Nextflow.id =>
         assert(entrypoint.isDefined, "In a Nextflow script, the 'entrypoint' argument needs to be specified.")
         NextflowScript(path = path, text = text, dest = dest, is_executable = is_executable, parent = parent, entrypoint = entrypoint.get)
-      case PythonScript.`type` =>
+      case Python.id =>
         PythonScript(path = path, text = text, dest = dest, is_executable = is_executable, parent = parent)
-      case RScript.`type` =>
+      case R.id =>
         RScript(path = path, text = text, dest = dest, is_executable = is_executable, parent = parent)
-      case ScalaScript.`type` =>
+      case Scala.id =>
         ScalaScript(path = path, text = text, dest = dest, is_executable = is_executable, parent = parent)
     }
   }