feat: download progress bar

Cargo.toml

@@ -17,12 +17,12 @@ clap = "3.0.0-beta.2"
 clap_generate = "3.0.0-beta.2"
 colored = "2.0.0"
 dirs-next = "2.0.0"
+indicatif = "0.16.0"
 indoc = "1.0.3"
 semver = "0.11.0"
 serde = { version = "1.0.123", features = ["derive"] }
 serde_json = "1.0.62"
 tar = "0.4.32"
-tempfile = "3.2.0"
 ureq = { version = "2.0.1", features = ["json"] }
 url = "2.2.0"
 xz2 = "0.1.6"

src/archive.rs

@@ -1,18 +1,19 @@
-use std::path::Path;
-use ureq::Response;
+use std::{io::Cursor, path::Path};
 
 pub struct Archive {
-    res: Response,
+    reader: Cursor<Vec<u8>>,
 }
 
 impl Archive {
-    pub fn new(res: Response) -> Self {
-        Archive { res }
+    pub fn new(buf: Vec<u8>) -> Self {
+        Self {
+            reader: Cursor::new(buf),
+        }
     }
 
     #[cfg(unix)]
     pub fn extract_into<P: AsRef<Path>>(self, path: P) -> anyhow::Result<()> {
-        let xz_stream = xz2::read::XzDecoder::new(self.res.into_reader());
+        let xz_stream = xz2::read::XzDecoder::new(self.reader);
         let mut archive = tar::Archive::new(xz_stream);
         archive.unpack(path).map_err(|e| anyhow::Error::new(e))
     }
@@ -21,10 +22,7 @@ impl Archive {
     pub fn extract_into<P: AsRef<Path>>(self, path: P) -> anyhow::Result<()> {
         use std::{fs, io};
 
-        let mut reader = self.res.into_reader();
-        let mut temp_zip = tempfile::tempfile()?;
-        std::io::copy(&mut reader, &mut temp_zip)?;
-        let mut archive = zip::read::ZipArchive::new(&mut temp_zip)?;
+        let mut archive = zip::read::ZipArchive::new(self.reader)?;
 
         for i in 0..archive.len() {
             let mut file = archive.by_index(i)?;

src/downloader.rs

@@ -1,9 +1,10 @@
-use crate::archive::Archive;
 use crate::config::Config;
 use crate::fetcher::Release;
 use crate::symlink::symlink_to;
 use crate::url;
+use crate::{archive::Archive, progress_bar::Bar};
 use colored::*;
+use indicatif::HumanBytes;
 use std::path::PathBuf;
 use ureq;
 
@@ -22,15 +23,24 @@ pub fn download(r: &Release, config: &Config) -> anyhow::Result<PathBuf> {
     let res = ureq::get(&dist.url).call()?;
     let len = res
         .header("Content-Length")
-        .and_then(|x| x.parse::<usize>().ok())
-        .ok_or(anyhow::Error::msg("Unable to get content length."))?;
+        .and_then(|x| x.parse::<u64>().ok());
 
-    println!("Installing  : {}", &r.version.to_string().bold());
-    println!("Downloading : {}", &dist.url.bold());
-    println!("Size        : {}", &len.to_string().bold());
-    println!("---");
+    let size = match len {
+        Some(l) => HumanBytes(l).to_string(),
+        None => "unknown".into(),
+    };
 
-    Archive::new(res).extract_into(&release_dir)?;
+    println!("Installing  : {}", r.version.to_string().bold());
+    println!("Downloading : {}", dist.url.bold());
+    println!("Size        : {}", size.bold());
+
+    println!();
+
+    let buf = Bar::new(len).read_start(res.into_reader())?;
+
+    println!();
+
+    Archive::new(buf).extract_into(&release_dir)?;
 
     std::fs::rename(&release_dir.join(dist.name), &dest)?;
 

src/main.rs

@@ -5,6 +5,7 @@ mod cmd;
 mod config;
 mod downloader;
 mod fetcher;
+mod progress_bar;
 mod shell;
 mod symlink;
 mod sysinfo;

src/progress_bar.rs

@@ -0,0 +1,69 @@
+// https://mattgathu.github.io/2017/08/29/writing-cli-app-rust.html
+use indicatif::{ProgressBar, ProgressStyle};
+use std::io::Read;
+
+const TEMPLATE: &'static str =
+    "{spinner:.green} [{elapsed_precise}] [{wide_bar:.cyan/blue}] {bytes}/{total_bytes} ({eta})";
+
+pub struct Bar {
+    len: Option<u64>,
+    bar: ProgressBar,
+    chunk_size: usize,
+}
+
+impl Bar {
+    pub fn new(len: Option<u64>) -> Self {
+        let (bar, chunk_size) = match len {
+            Some(x) => {
+                let bar = ProgressBar::new(x);
+
+                bar.set_style(
+                    ProgressStyle::default_bar()
+                        .template(TEMPLATE)
+                        .progress_chars("#>-"),
+                );
+
+                (bar, x as usize / 99)
+            }
+            None => {
+                let bar = ProgressBar::new_spinner();
+
+                bar.set_style(ProgressStyle::default_spinner());
+
+                (bar, 1024usize)
+            }
+        };
+
+        Self {
+            len,
+            bar,
+            chunk_size,
+        }
+    }
+
+    pub fn read_start(&self, mut reader: impl Read) -> anyhow::Result<Vec<u8>> {
+        let mut buf: Vec<u8> = match self.len {
+            Some(x) => Vec::with_capacity(x as usize),
+            None => Vec::new(),
+        };
+
+        loop {
+            let mut buffer = vec![0; self.chunk_size];
+            let bcount = reader.read(&mut buffer[..])?;
+
+            buffer.truncate(bcount);
+
+            if !buffer.is_empty() {
+                buf.extend(buffer.iter());
+
+                self.bar.inc(bcount as u64);
+            } else {
+                break;
+            }
+        }
+
+        self.bar.finish();
+
+        Ok(buf)
+    }
+}