feat: support self_update feature (#20)

Author: fioncat

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "roxide"
-version = "0.2.0"
+version = "0.3.0"
 edition = "2021"
 categories = ["command-line-utilities"]
 readme = "README.md"

Cargo.toml

@@ -118,10 +118,19 @@ ensure_command() {
 ensure_command "perl"
 ensure_command "tar"
 
-BIN_DIR="/usr/local/bin"
+if [[ $# -ge 1 ]]; then
+	BIN_DIR="$1"
+else
+	BIN_DIR="/usr/local/bin"
+fi
 TMP_DIR="/tmp/roxide-install"
 BASE_URL="https://github.com/fioncat/roxide/releases"
 
+SKIP_CONFIRM="false"
+if [[ $# -ge 2 ]]; then
+	SKIP_CONFIRM="$2"
+fi
+
 PLATFORM="$(detect_os)"
 ARCH="$(detect_arch)"
 
@@ -140,7 +149,12 @@ if [ -z ${SUPPORT} ]; then
 	exit 1
 fi
 
-confirm "Install roxide to ${BIN_DIR}?"
+if [[ ! "${SKIP_CONFIRM}" == "true" ]]; then
+	confirm "Install roxide to ${BIN_DIR}?"
+else
+	info "About to install roxide to ${BIN_DIR}"
+fi
+
 
 if [ -d ${TMP_DIR} ]; then
 	rm -r ${TMP_DIR}
@@ -193,6 +207,10 @@ if ! grep -q "$INIT_ROXIDE_SEARCH" "$PROFILE_PATH"; then
 fi
 
 
+if [[ "${SKIP_CONFIRM}" == "true" ]]; then
+	exit 0
+fi
+
 cat << EOF
 
 Congratulations! roxide has been already installed (or updated) to ${CYAN}${BIN_DIR}${RESET}.

install.sh

@@ -1,3 +1,5 @@
+use std::time::Duration;
+
 use anyhow::{bail, Context, Result};
 use reqwest::blocking::{Client, Request};
 use reqwest::{Method, Url};
@@ -34,6 +36,11 @@ struct Error {
     pub message: String,
 }
 
+#[derive(Debug, Deserialize)]
+struct Release {
+    pub tag_name: String,
+}
+
 impl Repo {
     fn to_api(self) -> ApiRepo {
         let Repo {
@@ -177,6 +184,18 @@ impl Github {
         })
     }
 
+    pub fn new_empty() -> Github {
+        let client = Client::builder()
+            .timeout(Duration::from_secs_f32(20.0))
+            .build()
+            .unwrap();
+        Github {
+            token: None,
+            per_page: 30,
+            client,
+        }
+    }
+
     fn execute_get<T>(&self, path: &str) -> Result<T>
     where
         T: DeserializeOwned + ?Sized,
@@ -233,4 +252,10 @@ impl Github {
         }
         builder.build().context("Build Github request")
     }
+
+    pub fn get_latest_tag(&self, owner: &str, name: &str) -> Result<String> {
+        let path = format!("repos/{owner}/{name}/releases/latest");
+        let release = self.execute_get::<Release>(&path)?;
+        Ok(release.tag_name)
+    }
 }

src/api/github.rs

@@ -1,5 +1,5 @@
 mod cache;
-mod github;
+pub mod github;
 mod gitlab;
 pub mod types;
 

src/api/mod.rs

@@ -1,4 +1,4 @@
-use anyhow::Result;
+use anyhow::{Context, Result};
 use clap::{Parser, Subcommand};
 
 use crate::cmd::run::attach::AttachArgs;
@@ -17,7 +17,9 @@ use crate::cmd::run::remove::RemoveArgs;
 use crate::cmd::run::reset::ResetArgs;
 use crate::cmd::run::squash::SquashArgs;
 use crate::cmd::run::tag::TagArgs;
+use crate::cmd::run::update::UpdateArgs;
 use crate::cmd::Run;
+use crate::self_update;
 
 #[derive(Parser)]
 #[command(author, version, about)]
@@ -44,10 +46,15 @@ pub enum Commands {
     Release(ReleaseArgs),
     Open(OpenArgs),
     Reset(ResetArgs),
+    Update(UpdateArgs),
 }
 
 impl Run for App {
     fn run(&self) -> Result<()> {
+        match &self.command {
+            Commands::Update(_) | Commands::Init(_) | Commands::Complete(_) => {}
+            _ => self_update::auto().context("Check auto self-update")?,
+        }
         match &self.command {
             Commands::Init(args) => args.run(),
             Commands::Home(args) => args.run(),
@@ -65,6 +72,7 @@ impl Run for App {
             Commands::Release(args) => args.run(),
             Commands::Open(args) => args.run(),
             Commands::Reset(args) => args.run(),
+            Commands::Update(args) => args.run(),
         }
     }
 }

src/cmd/app.rs

@@ -14,3 +14,4 @@ pub mod remove;
 pub mod reset;
 pub mod squash;
 pub mod tag;
+pub mod update;

src/cmd/run/mod.rs

@@ -0,0 +1,15 @@
+use anyhow::Result;
+use clap::Args;
+
+use crate::cmd::Run;
+use crate::self_update;
+
+/// If there is a new version, update roxide
+#[derive(Args)]
+pub struct UpdateArgs {}
+
+impl Run for UpdateArgs {
+    fn run(&self) -> Result<()> {
+        self_update::trigger()
+    }
+}

src/cmd/run/update.rs

@@ -3,6 +3,7 @@ mod cmd;
 mod config;
 mod errors;
 mod repo;
+mod self_update;
 mod shell;
 mod utils;
 

src/main.rs

@@ -0,0 +1,89 @@
+use std::io::ErrorKind;
+use std::path::PathBuf;
+use std::{env, fs};
+
+use anyhow::{bail, Context, Result};
+use console::style;
+
+use crate::api::github::Github;
+use crate::shell::Shell;
+use crate::{config, confirm, info, utils};
+
+pub fn trigger() -> Result<()> {
+    let exec_path = env::current_exe().context("Get current exec path")?;
+    let exec_dir = match exec_path.parent() {
+        Some(dir) => dir,
+        None => bail!("Invalid exec path {}", exec_path.display()),
+    };
+    info!("Checking new version for roxide");
+    let api = Github::new_empty();
+    let latest = api.get_latest_tag("fioncat", "roxide")?;
+    let current = env!("CARGO_PKG_VERSION");
+    let current = format!("v{current}");
+    if latest.as_str() == current {
+        info!("Your roxide is up-to-date");
+        return Ok(());
+    }
+
+    confirm!(
+        "Found new version {} for roxide, do you want to update",
+        style(&latest).magenta()
+    );
+
+    let update_script = include_bytes!("../install.sh");
+    let path = PathBuf::from(&config::base().metadir).join("update.sh");
+    utils::write_file(&path, update_script)?;
+
+    let script = format!("sh {} {} true", path.display(), exec_dir.display());
+    let mut shell = Shell::sh(&script);
+    shell.with_desc("Execute update script");
+    shell.execute()?.check()?;
+
+    info!("Update roxide to {} done", latest);
+    Ok(())
+}
+
+pub fn auto() -> Result<()> {
+    match env::var_os("ROXIDE_AUTO_UPDATE") {
+        Some(auto_update_opt) => match auto_update_opt.to_str() {
+            Some(opt) => match opt.to_lowercase().as_str() {
+                "yes" | "true" => {}
+                _ => return Ok(()),
+            },
+            _ => return Ok(()),
+        },
+        None => return Ok(()),
+    }
+    let now = config::now_secs();
+    let last_update = get_last_update_time()?;
+    let duration = now.saturating_sub(last_update);
+    if duration < utils::DAY {
+        return Ok(());
+    }
+    write_last_update_time(now)?;
+
+    trigger()
+}
+
+fn get_last_update_time() -> Result<u64> {
+    let path = PathBuf::from(&config::base().metadir).join("last_update");
+    utils::ensure_dir(&path)?;
+
+    match fs::read(&path) {
+        Ok(data) => {
+            let time = String::from_utf8(data).context("Decode last_update utf-8")?;
+            let time = time
+                .parse::<u64>()
+                .context("Parse last_update as integer")?;
+            Ok(time)
+        }
+        Err(err) if err.kind() == ErrorKind::NotFound => Ok(0),
+        Err(err) => Err(err).with_context(|| format!("Read last_update file {}", path.display())),
+    }
+}
+
+fn write_last_update_time(now: u64) -> Result<()> {
+    let path = PathBuf::from(&config::base().metadir).join("last_update");
+    let content = format!("{now}");
+    utils::write_file(&path, content.as_bytes()).context("Write last_update file")
+}