Merge pull request #26 from thedodd/1-better-terminal-output

Better terminal output.

Author: thedodd

CHANGELOG.md

@@ -3,6 +3,9 @@ changelog
 
 ## Unreleased
 ### changed
+- All CLI output has been improved using console & indicatif. Builds, asset pipelines, and the like are using a progress spinner along with messages. All in all this provides a much more clean CLI output experience.
+- Using `console::Emoji` to ensure that emojis are only sent to stdout/stderr when supported.
+- All builds performed by trunk now emit warnings when a link is found in the HTML which is an invalid FS path. This does not effect hyperlinks of course.
 - `trunk serve` now takes the `--open` option to control whether or not a browser tab will be opened. Thanks @MartinKavik for the report.
 - The `trunk serve` listener info has been slightly updated. It continues to function as in previous releases. Thanks @MartinKavik for the report.
 

Cargo.lock

@@ -14,7 +14,9 @@ keywords = ["wasm", "bundler", "web", "build-tool", "compiler"]
 anyhow = "1.0.32"
 async-process = "0.1.1"
 async-std = { version="1.6.3", features=["attributes", "unstable"] }
+console = "0.12.0"
 futures = "0.3.5"
+indicatif = "0.15.0"
 nipper = "0.1.8"
 notify = "4.0.15"
 open = "1.4.0"

Cargo.toml

@@ -5,10 +5,12 @@ use std::path::PathBuf;
 use std::sync::Arc;
 
 use anyhow::{anyhow, bail, ensure, Result};
+use async_process::{Command, Stdio};
 use async_std::fs;
 use async_std::task::{spawn, spawn_blocking, JoinHandle};
-use async_process::{Command, Stdio};
+use console::Emoji;
 use futures::stream::{FuturesUnordered, StreamExt};
+use indicatif::ProgressBar;
 use nipper::Document;
 use serde::{Serialize, Deserialize};
 
@@ -25,25 +27,28 @@ const HREF_ATTR: &str = "href";
 /// build routines can be cleanly abstracted away form any specific CLI endpoints.
 pub struct BuildSystem {
     /// The `Cargo.toml` manifest of the app being built.
-    pub manifest: CargoManifest,
+    manifest: CargoManifest,
     /// The path to the source HTML document from which the output `index.html` will be built.
-    pub target_html_path: Arc<PathBuf>,
+    target_html_path: Arc<PathBuf>,
     /// The parent directory of `target_html_path`.
-    pub target_html_dir: Arc<PathBuf>,
+    target_html_dir: Arc<PathBuf>,
     /// Build in release mode.
-    pub release: bool,
+    release: bool,
     /// The output dir for all final assets.
-    pub dist: Arc<PathBuf>,
+    dist: Arc<PathBuf>,
     /// The public URL from which assets are to be served.
     public_url: String,
 
     /// The output dir of the wasm-bindgen execution.
-    pub bindgen_out: Arc<PathBuf>,
+    bindgen_out: Arc<PathBuf>,
     /// The path to the app's output WASM.
-    pub app_target_wasm: Arc<PathBuf>,
+    app_target_wasm: Arc<PathBuf>,
 
     /// A stream of asset pipelines.
-    pub pipelines: FuturesUnordered<JoinHandle<Result<AssetPipelineOutput>>>,
+    pipelines: FuturesUnordered<JoinHandle<Result<AssetPipelineOutput>>>,
+
+    /// The object used for writing data to stdout, stderr & controlling the progress spinner.
+    progress: ProgressBar,
 }
 
 impl BuildSystem {
@@ -76,11 +81,30 @@ impl BuildSystem {
             bindgen_out: Arc::new(bindgen_out),
             app_target_wasm: Arc::new(app_target_wasm),
             pipelines: FuturesUnordered::new(),
+            progress: ProgressBar::new_spinner(),
         })
     }
 
+    /// Get a handle to the progress / terminal system.
+    pub fn get_progress_handle(&self) -> ProgressBar {
+        self.progress.clone()
+    }
+
     /// Build the application described in the given build data.
     pub async fn build_app(&mut self) -> Result<()> {
+        self.progress.reset();
+        self.progress.enable_steady_tick(100);
+        let res = self.build_app_internal().await;
+        self.progress.disable_steady_tick();
+        if let Err(err) = res {
+            self.progress.finish_with_message(&format!("{}build finished with errors", Emoji("❌ ", "")));
+            return Err(err);
+        }
+        self.progress.finish_with_message(&format!("{}build completed successfully", Emoji("✅ ", "")));
+        Ok(())
+    }
+
+    async fn build_app_internal(&mut self) -> Result<()> {
         // Update the contents of the source HTML.
         let target_html_raw = fs::read_to_string(self.target_html_path.as_ref()).await?;
         let mut target_html = Document::from(&target_html_raw);
@@ -117,7 +141,7 @@ impl BuildSystem {
             let asset = match asset_res {
                 Ok(asset) => asset,
                 Err(err) => {
-                    eprintln!("{}", err);
+                    self.progress.println(format!("{}", err));
                     continue;
                 }
             };
@@ -154,7 +178,7 @@ impl BuildSystem {
         if self.release {
             args.push("--release");
         }
-        println!("starting cargo build on {}", &self.manifest.package.name); // TODO: pin down logging.
+        self.progress.set_message(&format!("{}starting cargo build on {}", Emoji("📦 ", ""), &self.manifest.package.name));
         let app_target_wasm = self.app_target_wasm.clone();
         spawn(async move {
             // Spawn the cargo build process.
@@ -187,7 +211,7 @@ impl BuildSystem {
     fn spawn_wasm_bindgen_build(&self, file_name: String) -> JoinHandle<Result<WasmBindgenOutput>> {
         let (dist, bindgen_out, app_target_wasm) = (self.dist.clone(), self.bindgen_out.clone(), self.app_target_wasm.clone());
 
-        println!("starting wasm-bindgen build"); // TODO: pin down logging.
+        self.progress.set_message(&format!("{}starting wasm-bindgen build", Emoji("📦 ", "")));
         spawn(async move {
             let arg_out_path = format!("--out-dir={}", bindgen_out.display());
             let arg_out_name = format!("--out-name={}", &file_name);
@@ -232,7 +256,7 @@ impl BuildSystem {
     /// for the asset is finished, it will be able to update the DOM correctly based on its own
     /// ID. All of these trunk specific IDs will be removed from the DOM before it is written.
     async fn spawn_asset_pipelines(&mut self, target_html: &mut Document) -> Result<()> {
-        println!("spawning asset pipelines");
+        self.progress.set_message(&format!("{}spawning asset pipelines", Emoji("📦 ", "")));
 
         // Accumulate assets declared in HTML head section links for processing.
         let asset_links = target_html.select(r#"html head link"#)
@@ -254,7 +278,7 @@ impl BuildSystem {
             let path = self.target_html_dir.join(href.as_ref());
             let rel = node.attr_or("rel", "").to_string().to_lowercase();
             let id = format!("link-{}", idx);
-            let asset = match AssetFile::new(path, AssetType::Link{rel}, id).await {
+            let asset = match AssetFile::new(path, AssetType::Link{rel}, id, &self.progress).await {
                 Ok(asset) => asset,
                 Err(_) => continue,
             };
@@ -291,8 +315,7 @@ impl BuildSystem {
 
     /// Spawn a concurrent build pipeline for a SASS/SCSS asset.
     fn spawn_sass_pipeline(&mut self, asset: AssetFile) -> JoinHandle<Result<AssetPipelineOutput>> {
-        let dist = self.dist.clone();
-        let release = self.release;
+        let (dist, release, progress) = (self.dist.clone(), self.release, self.progress.clone());
         spawn(async move {
             // Compile the target SASS/SCSS file.
             let path_str = asset.path.to_string_lossy().to_string();
@@ -304,7 +327,7 @@ impl BuildSystem {
                 match sass_rs::compile_file(&path_str, opts) {
                     Ok(css) => Ok(css),
                     Err(err) => {
-                        eprintln!("{}", err);
+                        progress.println(format!("{}", err));
                         Err(anyhow!("error compiling sass for {}", &path_str))
                     }
                 }
@@ -377,13 +400,13 @@ impl AssetFile {
     ///
     /// Any errors returned from this constructor indicate that one of these invariants was not
     /// upheld.
-    pub async fn new(path: PathBuf, atype: AssetType, id: String) -> Result<Self> {
+    pub async fn new(path: PathBuf, atype: AssetType, id: String, progress: &ProgressBar) -> Result<Self> {
         // Take the path to referenced resource, if it is actually an FS path, then we continue.
         let path = match fs::canonicalize(&path).await {
             Ok(path) => path,
             Err(_) => {
                 if !path.to_string_lossy().contains("://") {
-                    eprintln!("skipping invalid path: {}", path.to_string_lossy());
+                    progress.println(format!("{}skipping invalid path: {}", Emoji("︎🚫 ", ""), path.to_string_lossy()));
                 }
                 return Err(anyhow!("skipping asset which is not a valid path"));
             }

src/build.rs

@@ -4,6 +4,8 @@ use std::sync::Arc;
 use anyhow::Result;
 use async_std::fs;
 use async_std::task::{spawn, spawn_local, JoinHandle};
+use console::Emoji;
+use indicatif::ProgressBar;
 use structopt::StructOpt;
 use tide::{Request, Response, Middleware, Next, StatusCode};
 use tide::http::mime;
@@ -46,16 +48,17 @@ impl Serve {
         );
         let mut watcher = WatchSystem::new(target, release, dist, public_url, ignore).await?;
         watcher.build().await;
+        let progress = watcher.get_progress_handle();
 
         // Spawn the watcher & the server.
         let http_addr = format!("http://127.0.0.1:{}{}", self.port, &self.public_url);
         let watch_handle = spawn_local(watcher.run());
-        let server_handle = self.spawn_server(http_addr.clone())?;
+        let server_handle = self.spawn_server(http_addr.clone(), progress.clone())?;
 
         // Open the browser.
         if self.open {
             if let Err(err) = open::that(http_addr) {
-                eprintln!("error opening browser: {}", err);
+                progress.println(format!("error opening browser: {}", err));
             }
         }
 
@@ -64,7 +67,7 @@ impl Serve {
         Ok(())
     }
 
-    fn spawn_server(&self, http_addr: String) -> Result<JoinHandle<()>> {
+    fn spawn_server(&self, http_addr: String, progress: ProgressBar) -> Result<JoinHandle<()>> {
         // Prep state.
         let listen_addr = format!("0.0.0.0:{}", self.port);
         let index = Arc::new(self.dist.join("index.html"));
@@ -75,10 +78,10 @@ impl Serve {
         app.at(&self.public_url).serve_dir(self.dist.to_string_lossy().as_ref())?;
 
         // Listen and serve.
-        println!("Server running at {}", &http_addr);
+        progress.println(format!("{}server running at {}\n", Emoji("📡 ", "  "), &http_addr));
         Ok(spawn(async move {
             if let Err(err) = app.listen(listen_addr).await {
-                eprintln!("{}", err);
+                progress.println(format!("{}", err));
             }
         }))
     }

src/cmd/serve.rs

@@ -30,8 +30,7 @@ pub struct Watch {
 
 impl Watch {
     pub async fn run(self) -> Result<()> {
-        let mut system = WatchSystem::new(self.target, self.release, self.dist, self.public_url, self.ignore.unwrap_or_default())
-            .await?;
+        let mut system = WatchSystem::new(self.target, self.release, self.dist, self.public_url, self.ignore.unwrap_or_default()).await?;
         system.build().await;
         system.run().await;
         Ok(())

src/cmd/watch.rs

@@ -5,7 +5,9 @@ use std::time::Duration;
 use anyhow::{anyhow, Result};
 use async_std::sync::channel;
 use async_std::task::spawn_blocking;
+use console::Emoji;
 use futures::stream::{FusedStream, StreamExt};
+use indicatif::ProgressBar;
 use notify::{Watcher, RecursiveMode, watcher};
 
 use crate::common::get_cwd;
@@ -15,6 +17,7 @@ use crate::build::{BuildSystem, CargoManifest};
 pub struct WatchSystem {
     build: BuildSystem,
     watcher: TrunkWatcher,
+    progress: ProgressBar,
 }
 
 impl WatchSystem {
@@ -29,41 +32,47 @@ impl WatchSystem {
         })?;
         ignore.append(&mut vec![cwd.join("target"), cwd.join(&dist)]);
 
-        // Build the watcher.
-        let watcher = TrunkWatcher::new(ignore)?;
-
         // Perform an initial build.
         let manifest = CargoManifest::read_cwd_manifest().await?;
         let build = BuildSystem::new(manifest, target, release, dist, public_url).await?;
-        Ok(Self{build, watcher})
+        let progress = build.get_progress_handle();
+
+        let watcher = TrunkWatcher::new(ignore, progress.clone())?;
+        Ok(Self{build, watcher, progress})
     }
 
     /// Run a build.
     pub async fn build(&mut self) {
         if let Err(err) = self.build.build_app().await {
-            eprintln!("{}", err);
+            self.progress.println(format!("{}", err));
         }
     }
 
     /// Run the watch system, responding to events and triggering builds.
     pub async fn run(mut self) {
         while let Some(_) = self.watcher.rx.next().await {
             if let Err(err) = self.build.build_app().await {
-                eprintln!("{}", err);
+                self.progress.println(format!("{}", err));
             }
         }
     }
+
+    /// Get a handle to the progress / terminal system.
+    pub fn get_progress_handle(&self) -> ProgressBar {
+        self.build.get_progress_handle()
+    }
 }
 
 /// A watcher system for triggering Trunk builds.
 struct TrunkWatcher {
-    pub watcher: notify::RecommendedWatcher,
-    pub rx: Box<dyn FusedStream<Item=()> + Send + Unpin>,
+    #[allow(dead_code)]
+    watcher: notify::RecommendedWatcher,
+    rx: Box<dyn FusedStream<Item=()> + Send + Unpin>,
 }
 
 impl TrunkWatcher {
     /// Spawn a watcher to trigger builds as changes are detected on the filesystem.
-    pub fn new(ignore: Vec<PathBuf>) -> Result<TrunkWatcher> {
+    pub fn new(ignore: Vec<PathBuf>, progress: ProgressBar) -> Result<TrunkWatcher> {
         // Setup core watcher functionality.
         let (tx, rx) = std_channel();
         let mut watcher = watcher(tx, Duration::from_secs(1))
@@ -88,8 +97,8 @@ impl TrunkWatcher {
                             let _ = async_tx.try_send(());
                         }
                         Event::Error(err, path_opt) => match path_opt {
-                            Some(path) => eprintln!("watch error at {}\n{}", path.to_string_lossy(), err),
-                            None => eprintln!("{}", err),
+                            Some(path) => progress.println(&format!("{}watch error at {}\n{}", Emoji("🚫 ", ""), path.to_string_lossy(), err)),
+                            None => progress.println(format!("{}", err)),
                         }
                         _ => continue,
                     }