feat(cli): ✨ parallelized cli stages and removed rollup

arctic-hen7 · arctic-hen7 · commit 7693ebf524cb · 2021-09-16T08:25:14.000+10:00
Perseus now has no JS dependencies and is >2x faster in builds! Closes #7. Closes #9.
diff --git a/examples/cli/.perseus/main.js b/examples/cli/.perseus/main.js
@@ -1,4 +1,4 @@
-import init, { run } from "./dist/pkg/perseus_cli_builder.js";
+import init, { run } from "/.perseus/bundle.js";
 async function main() {
     await init("/.perseus/bundle.wasm");
     run();
diff --git a/examples/cli/.perseus/server/src/main.rs b/examples/cli/.perseus/server/src/main.rs
@@ -19,7 +19,8 @@ async fn main() -> std::io::Result<()> {
             App::new().configure(block_on(configurer(
                 Options {
                     index: "../index.html".to_string(), // The user must define their own `index.html` file
-                    js_bundle: "dist/pkg/bundle.js".to_string(),
+                    js_bundle: "dist/pkg/perseus_cli_builder.js".to_string(),
+                    js_init: "main.js".to_string(),
                     // Our crate has the same name, so this will be predictable
                     wasm_bundle: "dist/pkg/perseus_cli_builder_bg.wasm".to_string(),
                     templates_map: get_templates_map(),
diff --git a/examples/i18n/index.html b/examples/i18n/index.html
@@ -6,7 +6,7 @@
         <meta name="viewport" content="width=device-width, initial-scale=1.0" />
         <title>Perseus Starter App</title>
         <!-- Importing this runs Perseus -->
-        <script src="/.perseus/bundle.js" defer></script>
+        <script type="module" src="/.perseus/main.js" defer></script>
     </head>
     <body>
         <div id="root"></div>
diff --git a/packages/perseus-actix-web/src/configurer.rs b/packages/perseus-actix-web/src/configurer.rs
@@ -9,6 +9,9 @@ use perseus::{get_render_cfg, ConfigManager, Locales, SsrNode, TemplateMap, Tran
 pub struct Options {
     /// The location on the filesystem of your JavaScript bundle.
     pub js_bundle: String,
+    /// The locales on the filesystem of the file that will invoke your JavaScript bundle. This should have something like `init()` in
+    /// it.
+    pub js_init: String,
     /// The location on the filesystem of your WASM bundle.
     pub wasm_bundle: String,
     /// The location on the filesystem of your `index.html` file that includes the JS bundle.
@@ -22,6 +25,9 @@ pub struct Options {
 async fn js_bundle(opts: web::Data<Options>) -> std::io::Result<NamedFile> {
     NamedFile::open(&opts.js_bundle)
 }
+async fn js_init(opts: web::Data<Options>) -> std::io::Result<NamedFile> {
+    NamedFile::open(&opts.js_init)
+}
 async fn wasm_bundle(opts: web::Data<Options>) -> std::io::Result<NamedFile> {
     NamedFile::open(&opts.wasm_bundle)
 }
@@ -48,6 +54,7 @@ pub async fn configurer<C: ConfigManager + 'static, T: TranslationsManager + 'st
             // TODO chunk JS and WASM bundles
             // These allow getting the basic app code (not including the static data)
             // This contains everything in the spirit of a pseudo-SPA
+            .route("/.perseus/main.js", web::get().to(js_init))
             .route("/.perseus/bundle.js", web::get().to(js_bundle))
             .route("/.perseus/bundle.wasm", web::get().to(wasm_bundle))
             // This allows getting the static HTML/JSON of a page
diff --git a/packages/perseus-cli/Cargo.toml b/packages/perseus-cli/Cargo.toml
@@ -22,7 +22,7 @@ include = [
 include_dir = "0.6"
 error-chain = "0.12"
 cargo_toml = "0.9"
-indicatif = "0.16"
+indicatif = "0.17.0-beta.1" # Not stable, but otherwise error handling is just about impossible
 console = "0.14"
 serde = "1"
 serde_json = "1"
diff --git a/packages/perseus-cli/src/build.rs b/packages/perseus-cli/src/build.rs
@@ -1,57 +1,28 @@
-use crate::cmd::run_stage;
+use crate::cmd::{cfg_spinner, run_stage};
 use crate::errors::*;
 use console::{style, Emoji};
+use indicatif::{MultiProgress, ProgressBar};
 use std::env;
 use std::fs;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
+use std::thread::{self, JoinHandle};
 
 // Emojis for stages
 static GENERATING: Emoji<'_, '_> = Emoji("🔨", "");
 static BUILDING: Emoji<'_, '_> = Emoji("🏗️ ", ""); // Yes, there's a space here, for some reason it's needed...
-static FINALIZING: Emoji<'_, '_> = Emoji("📦", "");
 
 /// Returns the exit code if it's non-zero.
 macro_rules! handle_exit_code {
     ($code:expr) => {
         let (_, _, code) = $code;
         if code != 0 {
-            return Ok(code);
+            return $crate::errors::Result::Ok(code);
         }
     };
 }
 
-/// Actually builds the user's code, program arguments having been interpreted. This needs to know how many steps there are in total
-/// because the serving logic also uses it.
-pub fn build_internal(dir: PathBuf, num_steps: u8) -> Result<i32> {
-    let mut target = dir;
-    target.extend([".perseus"]);
-
-    // Static generation
-    handle_exit_code!(run_stage(
-        vec![&format!(
-            "{} run",
-            env::var("PERSEUS_CARGO_PATH").unwrap_or_else(|_| "cargo".to_string())
-        )],
-        &target,
-        format!(
-            "{} {} Generating your app",
-            style(format!("[1/{}]", num_steps)).bold().dim(),
-            GENERATING
-        )
-    )?);
-    // WASM building
-    handle_exit_code!(run_stage(
-        vec![&format!(
-            "{} build --target web",
-            env::var("PERSEUS_WASM_PACK_PATH").unwrap_or_else(|_| "wasm-pack".to_string())
-        )],
-        &target,
-        format!(
-            "{} {} Building your app to WASM",
-            style(format!("[2/{}]", num_steps)).bold().dim(),
-            BUILDING
-        )
-    )?);
+/// Finalizes the build by renaming some directories.
+pub fn finalize(target: &Path) -> Result<()> {
     // Move the `pkg/` directory into `dist/pkg/`
     let pkg_dir = target.join("dist/pkg");
     if pkg_dir.exists() {
@@ -63,34 +34,98 @@ pub fn build_internal(dir: PathBuf, num_steps: u8) -> Result<i32> {
     if let Err(err) = fs::rename(target.join("pkg"), target.join("dist/pkg")) {
         bail!(ErrorKind::MovePkgDirFailed(err.to_string()));
     }
-    // JS bundle generation
-    handle_exit_code!(run_stage(
-        vec![&format!(
-            "{} main.js --format iife --file dist/pkg/bundle.js",
-            env::var("PERSEUS_ROLLUP_PATH").unwrap_or_else(|_| "rollup".to_string())
-        )],
-        &target,
-        format!(
-            "{} {} Finalizing bundle",
-            style(format!("[3/{}]", num_steps)).bold().dim(),
-            FINALIZING
-        )
-    )?);
 
-    Ok(0)
+    Ok(())
+}
+
+// This literally only exists to avoid type complexity warnings in the `build_internal`'s return type
+type ThreadHandle = JoinHandle<Result<i32>>;
+
+/// Actually builds the user's code, program arguments having been interpreted. This needs to know how many steps there are in total
+/// because the serving logic also uses it. This also takes a `MultiProgress` to interact with so it can be used truly atomically.
+/// This returns handles for waiting on the component threads so we can use it composably.
+pub fn build_internal(
+    dir: PathBuf,
+    spinners: &MultiProgress,
+    num_steps: u8,
+) -> Result<(ThreadHandle, ThreadHandle)> {
+    let target = dir.join(".perseus");
+
+    // Static generation message
+    let sg_msg = format!(
+        "{} {} Generating your app",
+        style(format!("[1/{}]", num_steps)).bold().dim(),
+        GENERATING
+    );
+    // Wasm building message
+    let wb_msg = format!(
+        "{} {} Building your app to Wasm",
+        style(format!("[2/{}]", num_steps)).bold().dim(),
+        BUILDING
+    );
+
+    // We parallelize the first two spinners (static generation and Wasm building)
+    // We make sure to add them at the top (the server spinner may have already been instantiated)
+    let sg_spinner = spinners.insert(0, ProgressBar::new_spinner());
+    let sg_spinner = cfg_spinner(sg_spinner, &sg_msg);
+    let sg_target = target.clone();
+    let wb_spinner = spinners.insert(1, ProgressBar::new_spinner());
+    let wb_spinner = cfg_spinner(wb_spinner, &wb_msg);
+    let wb_target = target.clone();
+    let sg_thread = thread::spawn(move || {
+        handle_exit_code!(run_stage(
+            vec![&format!(
+                "{} run",
+                env::var("PERSEUS_CARGO_PATH").unwrap_or_else(|_| "cargo".to_string())
+            )],
+            &sg_target,
+            &sg_spinner,
+            &sg_msg
+        )?);
+
+        Ok(0)
+    });
+    let wb_thread = thread::spawn(move || {
+        handle_exit_code!(run_stage(
+            vec![&format!(
+                "{} build --target web",
+                env::var("PERSEUS_WASM_PACK_PATH").unwrap_or_else(|_| "wasm-pack".to_string())
+            )],
+            &wb_target,
+            &wb_spinner,
+            &wb_msg
+        )?);
+
+        Ok(0)
+    });
+
+    Ok((sg_thread, wb_thread))
 }
 
 /// Builds the subcrates to get a directory that we can serve. Returns an exit code.
-pub fn build(dir: PathBuf, prog_args: &[String]) -> Result<i32> {
+pub fn build(dir: PathBuf, _prog_args: &[String]) -> Result<i32> {
+    let spinners = MultiProgress::new();
     // TODO support watching files
-    // If we should watch for file changes, do so
-    let should_watch = prog_args.get(1);
-    let dflt_watch_path = ".".to_string();
-    let _watch_path = prog_args.get(2).unwrap_or(&dflt_watch_path);
-    if should_watch == Some(&"-w".to_string()) || should_watch == Some(&"--watch".to_string()) {
-        todo!("watching not yet supported, try a tool like 'entr'");
+
+    let (sg_thread, wb_thread) = build_internal(dir.clone(), &spinners, 2)?;
+    let sg_res = sg_thread
+        .join()
+        .map_err(|_| ErrorKind::ThreadWaitFailed)??;
+    if sg_res != 0 {
+        return Ok(sg_res);
+    }
+    let wb_res = wb_thread
+        .join()
+        .map_err(|_| ErrorKind::ThreadWaitFailed)??;
+    if wb_res != 0 {
+        return Ok(wb_res);
     }
-    let exit_code = build_internal(dir.clone(), 3)?;
 
-    Ok(exit_code)
+    // This waits for all the threads and lets the spinners draw to the terminal
+    // spinners.join().map_err(|_| ErrorKind::ThreadWaitFailed)?;
+    // And now we can run the finalization stage
+    finalize(&dir.join(".perseus"))?;
+
+    // We've handled errors in the component threads, so the exit code is now zero
+    Ok(0)
 }
diff --git a/packages/perseus-cli/src/cmd.rs b/packages/perseus-cli/src/cmd.rs
@@ -12,9 +12,6 @@ pub static FAILURE: Emoji<'_, '_> = Emoji("❌", "failed!");
 /// Runs the given command conveniently, returning the exit code. Notably, this parses the given command by separating it on spaces.
 /// Returns the command's output and the exit code.
 pub fn run_cmd(cmd: String, dir: &Path, pre_dump: impl Fn()) -> Result<(String, String, i32)> {
-    // let mut cmd_args: Vec<&str> = raw_cmd.split(' ').collect();
-    // let cmd = cmd_args.remove(0);
-
     // We run the command in a shell so that NPM/Yarn binaries can be recognized (see #5)
     #[cfg(unix)]
     let shell_exec = "sh";
@@ -51,23 +48,39 @@ pub fn run_cmd(cmd: String, dir: &Path, pre_dump: impl Fn()) -> Result<(String,
     ))
 }
 
-/// Runs a series of commands and provides a nice spinner with a custom message. Returns the last command's output and an appropriate exit
-/// code (0 if everything worked, otherwise the exit code of the one that failed).
-pub fn run_stage(cmds: Vec<&str>, target: &Path, message: String) -> Result<(String, String, i32)> {
-    // Tell the user about the stage with a nice progress bar
-    let spinner = ProgressBar::new_spinner();
+/// Creates a new spinner.
+pub fn cfg_spinner(spinner: ProgressBar, message: &str) -> ProgressBar {
     spinner.set_style(ProgressStyle::default_spinner().tick_chars("⠁⠂⠄⡀⢀⠠⠐⠈ "));
-    spinner.set_message(format!("{}...", message));
+    spinner.set_message(format!("{}...", &message));
     // Tick the spinner every 50 milliseconds
     spinner.enable_steady_tick(50);
 
+    spinner
+}
+/// Instructs the given spinner to show success.
+pub fn succeed_spinner(spinner: &ProgressBar, message: &str) {
+    spinner.finish_with_message(format!("{}...{}", message, SUCCESS));
+}
+/// Instructs the given spinner to show failure.
+pub fn fail_spinner(spinner: &ProgressBar, message: &str) {
+    spinner.finish_with_message(format!("{}...{}", message, FAILURE));
+}
+
+/// Runs a series of commands. Returns the last command's output and an appropriate exit code (0 if everything worked, otherwise th
+/// exit code of the first one that failed). This also takes a `Spinner` to use and control.
+pub fn run_stage(
+    cmds: Vec<&str>,
+    target: &Path,
+    spinner: &ProgressBar,
+    message: &str,
+) -> Result<(String, String, i32)> {
     let mut last_output = (String::new(), String::new());
     // Run the commands
     for cmd in cmds {
         // We make sure all commands run in the target directory ('.perseus/' itself)
         let (stdout, stderr, exit_code) = run_cmd(cmd.to_string(), target, || {
-            // We're done, we'll write a more permanent version of the message
-            spinner.finish_with_message(format!("{}...{}", message, FAILURE))
+            // This stage has failed
+            fail_spinner(spinner, message);
         })?;
         last_output = (stdout, stderr);
         // If we have a non-zero exit code, we should NOT continue (stderr has been written to the console already)
@@ -76,8 +89,8 @@ pub fn run_stage(cmds: Vec<&str>, target: &Path, message: String) -> Result<(Str
         }
     }
 
-    // We're done, we'll write a more permanent version of the message
-    spinner.finish_with_message(format!("{}...{}", message, SUCCESS));
+    // Everything has worked for this stage
+    succeed_spinner(spinner, message);
 
     Ok((last_output.0, last_output.1, 0))
 }
diff --git a/packages/perseus-cli/src/errors.rs b/packages/perseus-cli/src/errors.rs
@@ -78,6 +78,11 @@ error_chain! {
             description("couldn't move `pkg/` to `dist/pkg/`")
             display("Couldn't move `.perseus/pkg/` to `.perseus/dist/pkg`. Error was: '{}'.", err)
         }
+        /// For when an error occurs while trying to wait for a thread.
+        ThreadWaitFailed {
+            description("error occurred while trying to wait for thread")
+            display("Waiting on thread failed.")
+        }
     }
 }
 
diff --git a/packages/perseus-cli/src/prepare.rs b/packages/perseus-cli/src/prepare.rs
@@ -132,35 +132,32 @@ pub fn prepare(dir: PathBuf) -> Result<()> {
     }
 }
 
-/// Checks if the user has the necessary prerequisites on their system (i.e. `cargo`, `wasm-pack`, and `rollup`). These can all be checked
+/// Checks if the user has the necessary prerequisites on their system (i.e. `cargo` and `wasm-pack`). These can all be checked
 /// by just trying to run their binaries and looking for errors. If the user has other paths for these, they can define them under the
-/// environment variables `PERSEUS_CARGO_PATH`, `PERSEUS_WASM_PACK_PATH`, and `PERSEUS_ROLLUP_PATH`.
+/// environment variables `PERSEUS_CARGO_PATH` and `PERSEUS_WASM_PACK_PATH`.
 pub fn check_env() -> Result<()> {
     // We'll loop through each prerequisite executable to check their existence
     // If the spawn returns an error, it's considered not present, success means presence
     let prereq_execs = vec![
         (
             env::var("PERSEUS_CARGO_PATH").unwrap_or_else(|_| "cargo".to_string()),
+            "cargo",
             "PERSEUS_CARGO_PATH",
         ),
         (
             env::var("PERSEUS_WASM_PACK_PATH").unwrap_or_else(|_| "wasm-pack".to_string()),
+            "wasm-pack",
             "PERSEUS_WASM_PACK_PATH",
         ),
-        // We dangerously assume that the user isn't using `npx`...
-        (
-            env::var("PERSEUS_ROLLUP_PATH").unwrap_or_else(|_| "rollup".to_string()),
-            "PERSEUS_ROLLUP_PATH",
-        ),
     ];
 
     for exec in prereq_execs {
         let res = Command::new(&exec.0).output();
         // Any errors are interpreted as meaning that the user doesn't have the prerequisite installed properly.
         if let Err(err) = res {
             bail!(ErrorKind::PrereqFailed(
-                exec.0,
                 exec.1.to_string(),
+                exec.2.to_string(),
                 err.to_string()
             ))
         }
diff --git a/packages/perseus-cli/src/serve.rs b/packages/perseus-cli/src/serve.rs

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-import init, { run } from "./dist/pkg/perseus_cli_builder.js";`
	`1`	`+import init, { run } from "/.perseus/bundle.js";`
`2`	`2`	`async function main() {`
`3`	`3`	`await init("/.perseus/bundle.wasm");`
`4`	`4`	`run();`
Original file line number	Diff line number	Diff line change
`@@ -78,6 +78,11 @@ error_chain! {`
`78`	`78`	description("couldn't move `pkg/` to `dist/pkg/`")
`79`	`79`	display("Couldn't move `.perseus/pkg/` to `.perseus/dist/pkg`. Error was: '{}'.", err)
`80`	`80`	`}`
	`81`	`+ /// For when an error occurs while trying to wait for a thread.`
	`82`	`+ ThreadWaitFailed {`
	`83`	`+ description("error occurred while trying to wait for thread")`
	`84`	`+ display("Waiting on thread failed.")`
	`85`	`+ }`
`81`	`86`	`}`
`82`	`87`	`}`
`83`	`88`