Build support for the TypeScript target (#16)

* Work in progress toward NPM backend

* Invoke lfc instead of rustc

* add npm build

* draft of backend for npm

* fix format

* update clean

* add condition for run and build

* refactored typescript target

* rust fmt

* select correct npm or pnpm backend

* completely reworked the npm backend

* working pnpm backend

* fixing clippy

* unified npm and pnpm backend more beutifully

* removing print

* formatting default ts example

---------

Co-authored-by: jesslin02 <[email protected]>
Co-authored-by: revol-xut <[email protected]>

Author: 3 people

Cargo.lock

@@ -0,0 +1,5 @@
+target TypeScript
+
+main reactor {
+  reaction(startup) {= console.log("Hello World"); =}
+}

defaults/HelloTS.lf

@@ -3,7 +3,7 @@ use clap::{Args, Parser, Subcommand};
 use serde_derive::{Deserialize, Serialize};
 use std::path::PathBuf;
 
-#[derive(clap::ValueEnum, Clone, Copy, Debug, Deserialize, Serialize)]
+#[derive(clap::ValueEnum, Clone, Copy, Debug, Deserialize, Serialize, PartialEq)]
 pub enum TargetLanguage {
     C,
     Cpp,
@@ -23,6 +23,8 @@ pub enum BuildSystem {
     LFC,
     CMake,
     Cargo,
+    Npm,
+    Pnpm,
 }
 
 #[derive(Args, Debug)]

src/args.rs

@@ -11,6 +11,8 @@ use crate::{args::BuildSystem, package::App};
 
 pub mod cmake;
 pub mod lfc;
+pub mod npm;
+pub mod pnpm;
 
 pub fn execute_command<'a>(command: &CommandSpec, apps: &[&'a App]) -> BatchBuildResults<'a> {
     // Group apps by build system
@@ -39,6 +41,8 @@ pub fn execute_command<'a>(command: &CommandSpec, apps: &[&'a App]) -> BatchBuil
             BuildSystem::LFC => lfc::LFC.execute_command(command, &mut sub_res),
             BuildSystem::CMake => cmake::Cmake.execute_command(command, &mut sub_res),
             BuildSystem::Cargo => todo!(),
+            BuildSystem::Npm => npm::Npm.execute_command(command, &mut sub_res),
+            BuildSystem::Pnpm => pnpm::Pnpm.execute_command(command, &mut sub_res),
         };
         result.append(sub_res);
     }
@@ -64,6 +68,8 @@ pub struct BuildCommandOptions {
     /// that the number will be automatically determined.
     /// A value of one effectively disables parallel builds.
     pub max_threads: usize,
+    /// if compilation should continue if one of the apps fails building
+    pub keep_going: bool,
 }
 
 /// Description of a lingo command

src/backends/mod.rs

@@ -0,0 +1,109 @@
+use crate::util::errors::LingoError;
+use crate::util::execute_command_to_build_result;
+use std::error::Error;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+pub struct Npm;
+
+pub struct TypeScriptToolCommands {
+    pub binary_name: &'static str,
+    pub install_command: &'static str,
+    pub release_build_argument: &'static str,
+}
+
+use crate::backends::{
+    BatchBackend, BatchBuildResults, BuildCommandOptions, BuildProfile, CommandSpec,
+};
+
+pub fn do_typescript_build(
+    results: &mut BatchBuildResults,
+    options: &BuildCommandOptions,
+    commands: TypeScriptToolCommands,
+) {
+    super::lfc::LFC::do_parallel_lfc_codegen(options, results, false);
+    if !options.compile_target_code {
+        return;
+    }
+
+    let extract_name = |path: &PathBuf| -> Result<String, Box<dyn Error + Send + Sync>> {
+        match Path::new(&path).file_stem() {
+            Some(value) => value
+                .to_str()
+                .map(String::from)
+                .ok_or(Box::new(LingoError::InvalidMainReactor)),
+            None => Err(Box::new(LingoError::InvalidMainReactor)),
+        }
+    };
+
+    results
+        .map(|app| {
+            let file_name = extract_name(&app.main_reactor)?;
+            let path = app.output_root.join("src-gen").join(file_name);
+
+            let mut npm_install = Command::new(commands.binary_name);
+            npm_install.current_dir(path);
+            npm_install.arg(commands.install_command);
+            if options.profile == BuildProfile::Release {
+                npm_install.arg(commands.release_build_argument);
+            }
+            execute_command_to_build_result(npm_install)?;
+            Ok(())
+        })
+        .map(|app| {
+            let file_name = extract_name(&app.main_reactor)?;
+            let path = app.output_root.join("src-gen").join(file_name);
+
+            let mut npm_build = Command::new(commands.binary_name);
+            npm_build.current_dir(path);
+            npm_build.arg("run");
+            npm_build.arg("build");
+
+            if options.profile == BuildProfile::Release {
+                npm_build.arg(commands.release_build_argument);
+            }
+            execute_command_to_build_result(npm_build)?;
+
+            Ok(())
+        })
+        .map(|app| {
+            fs::create_dir_all(app.output_root.join("bin"))?;
+
+            let file_name = extract_name(&app.main_reactor)?;
+            let path = app
+                .output_root
+                .join("src-gen")
+                .join(&file_name)
+                .join("dist")
+                .join(file_name + ".js");
+
+            // cleanup: rename executable to match the app name
+            fs::rename(path, app.executable_path())?;
+            Ok(())
+        });
+}
+
+impl BatchBackend for Npm {
+    fn execute_command(&mut self, command: &CommandSpec, results: &mut BatchBuildResults) {
+        match command {
+            CommandSpec::Build(options) => do_typescript_build(
+                results,
+                options,
+                TypeScriptToolCommands {
+                    binary_name: "npm",
+                    install_command: "install",
+                    release_build_argument: "--production",
+                },
+            ),
+            CommandSpec::Clean => {
+                results.par_map(|app| {
+                    crate::util::default_build_clean(&app.output_root)?;
+                    crate::util::delete_subdirs(&app.output_root, &["node_modules", "dist"])?;
+                    Ok(())
+                });
+            }
+            _ => todo!(),
+        }
+    }
+}

src/backends/npm.rs

@@ -0,0 +1,29 @@
+use crate::backends::npm::{do_typescript_build, TypeScriptToolCommands};
+
+pub struct Pnpm;
+
+use crate::backends::{BatchBackend, BatchBuildResults, CommandSpec};
+
+impl BatchBackend for Pnpm {
+    fn execute_command(&mut self, command: &CommandSpec, results: &mut BatchBuildResults) {
+        match command {
+            CommandSpec::Build(options) => do_typescript_build(
+                results,
+                options,
+                TypeScriptToolCommands {
+                    binary_name: "pnpm",
+                    install_command: "install",
+                    release_build_argument: "--prod",
+                },
+            ),
+            CommandSpec::Clean => {
+                results.par_map(|app| {
+                    crate::util::default_build_clean(&app.output_root)?;
+                    crate::util::delete_subdirs(&app.output_root, &["node_modules", "dist"])?;
+                    Ok(())
+                });
+            }
+            _ => todo!(),
+        }
+    }
+}

src/backends/pnpm.rs

@@ -119,6 +119,7 @@ fn build<'a>(args: &BuildArgs, config: &'a Config) -> BatchBuildResults<'a> {
             compile_target_code: !args.no_compile,
             lfc_exec_path: util::find_lfc_exec(args).expect("TODO replace me"),
             max_threads: args.threads,
+            keep_going: args.keep_going,
         }),
         config,
         args.keep_going,

src/main.rs

@@ -13,6 +13,7 @@ use std::{env, io};
 use crate::args::BuildSystem::{CMake, Cargo, LFC};
 use crate::util::errors::{BuildResult, LingoError};
 use git2::Repository;
+use which::which;
 
 fn is_valid_location_for_project(path: &std::path::Path) -> bool {
     !path.join("src").exists() && !path.join(".git").exists() && !path.join("application").exists()
@@ -93,6 +94,13 @@ impl App {
         match self.target {
             TargetLanguage::Cpp => CMake,
             TargetLanguage::Rust => Cargo,
+            TargetLanguage::TypeScript => {
+                if which("pnpm").is_ok() {
+                    BuildSystem::Pnpm
+                } else {
+                    BuildSystem::Npm
+                }
+            }
             _ => LFC,
         }
     }
@@ -101,7 +109,11 @@ impl App {
     }
     pub fn executable_path(&self) -> PathBuf {
         let mut p = self.output_root.join("bin");
-        p.push(&self.name);
+        if self.target == TargetLanguage::TypeScript {
+            p.push(self.name.clone() + ".js")
+        } else {
+            p.push(&self.name);
+        }
         p
     }
 }
@@ -202,6 +214,7 @@ impl ConfigFile {
         let hello_world_code: &'static str = match self.apps[0].target {
             TargetLanguage::Cpp => include_str!("../../defaults/HelloCpp.lf"),
             TargetLanguage::C => include_str!("../../defaults/HelloC.lf"),
+            TargetLanguage::TypeScript => include_str!("../../defaults/HelloTS.lf"),
             _ => panic!("Target langauge not supported yet"), // FIXME: Add examples for other programs
         };
 

src/package/mod.rs

@@ -15,6 +15,7 @@ pub enum LingoError {
     UnknownAppNames(Vec<String>),
     InvalidProjectLocation(PathBuf),
     UseWestBuildToBuildApp,
+    InvalidMainReactor,
 }
 
 impl Display for LingoError {
@@ -35,6 +36,12 @@ impl Display for LingoError {
             LingoError::UseWestBuildToBuildApp => {
                 write!(f, "Use `west lf-build` to build and run Zephyr programs.")
             }
+            LingoError::InvalidMainReactor => {
+                write!(
+                    f,
+                    "Not a valid path path to a file that contains a main reactor"
+                )
+            }
         }
     }
 }