Add the ability for bob to add neovim proxy to $PATH

Cargo.toml

@@ -26,6 +26,7 @@ clap_complete = "4.1"
 toml = "0.8.8"
 semver = "1.0.22"
 sha2 = "0.10.8"
+what-the-path = "^0.1.3" 
 
 [dependencies.chrono]
 version = "0.4.23"
@@ -92,7 +93,7 @@ tar = "0.4"
 
 [target."cfg(windows)".dependencies]
 winreg = "0.10.1"
-zip = "0.5"
+zip = "2.2.0"
 
 
 [[bin]]

env/env.fish

@@ -0,0 +1,4 @@
+# Credit: https://github.com/rust-lang/rustup/blob/master/src/cli/self_update/env.fish
+if not contains "{nvim_bin}" $PATH
+    set -x PATH "{nvim_bin}" $PATH
+end

env/env.sh

@@ -0,0 +1,9 @@
+#!/bin/sh
+# Credit: https://github.com/rust-lang/rustup/blob/master/src/cli/self_update/env.sh
+case ":${PATH}:" in
+    *:"{nvim_bin}":*)
+        ;;
+    *)
+        export PATH="{nvim_bin}:$PATH"
+        ;;
+esac

src/cli.rs

@@ -1,5 +1,5 @@
 use crate::{
-    config::Config,
+    config::ConfigFile,
     handlers::{
         self, erase_handler, list_handler, list_remote_handler, rollback_handler, sync_handler,
         uninstall_handler, update_handler, InstallResult,
@@ -57,6 +57,8 @@ enum Cli {
     /// install command if the version is not installed already
     Use {
         /// Version to switch to |nightly|stable|<version-string>|<commit-hash>|
+        ///
+        /// A version-string can either be `vx.x.x` or `x.x.x` examples: `v0.6.1` and `0.6.0`
         version: String,
 
         /// Whether not to auto-invoke install command
@@ -68,6 +70,8 @@ enum Cli {
     /// out-of-date nightly version
     Install {
         /// Version to be installed |nightly|stable|<version-string>|<commit-hash>|
+        ///
+        /// A version-string can either be `vx.x.x` or `x.x.x` examples: `v0.6.1` and `0.6.0`
         version: String,
     },
 
@@ -79,6 +83,9 @@ enum Cli {
     #[clap(alias = "remove", visible_alias = "rm")]
     Uninstall {
         /// Optional Version to be uninstalled |nightly|stable|<version-string>|<commit-hash>|
+        ///
+        /// A version-string can either be `vx.x.x` or `x.x.x` examples: `v0.6.1` and `0.6.0`
+        ///
         /// If no Version is provided a prompt is used to select the versions to be uninstalled
         version: Option<String>,
     },
@@ -153,7 +160,7 @@ pub struct Update {
 /// let config = Config::default();
 /// start(config).await.unwrap();
 /// ```
-pub async fn start(config: Config) -> Result<()> {
+pub async fn start(config: ConfigFile) -> Result<()> {
     let client = create_reqwest_client()?;
     let cli = Cli::parse();
 
@@ -191,18 +198,18 @@ pub async fn start(config: Config) -> Result<()> {
         }
         Cli::Uninstall { version } => {
             info!("Starting uninstallation process");
-            uninstall_handler::start(version.as_deref(), config).await?;
+            uninstall_handler::start(version.as_deref(), config.config).await?;
         }
-        Cli::Rollback => rollback_handler::start(config).await?,
-        Cli::Erase => erase_handler::start(config).await?,
-        Cli::List => list_handler::start(config).await?,
+        Cli::Rollback => rollback_handler::start(config.config).await?,
+        Cli::Erase => erase_handler::start(config.config).await?,
+        Cli::List => list_handler::start(config.config).await?,
         Cli::Complete { shell } => {
             clap_complete::generate(shell, &mut Cli::command(), "bob", &mut std::io::stdout())
         }
         Cli::Update(data) => {
             update_handler::start(data, &client, config).await?;
         }
-        Cli::ListRemote => list_remote_handler::start(config, client).await?,
+        Cli::ListRemote => list_remote_handler::start(config.config, client).await?,
     }
 
     Ok(())

src/config.rs

@@ -1,8 +1,84 @@
 use anyhow::Result;
 use regex::Regex;
 use serde::{Deserialize, Serialize};
-use std::env;
-use tokio::fs::{self};
+use std::{env, path::PathBuf};
+use tokio::{
+    fs::{self, File},
+    io::AsyncWriteExt,
+};
+
+#[derive(Debug, Clone)]
+pub struct ConfigFile {
+    pub path: PathBuf,
+    pub format: ConfigFormat,
+    pub config: Config,
+}
+
+impl ConfigFile {
+    pub async fn save_to_file(&self) -> Result<()> {
+        if let Some(parent) = self.path.parent() {
+            tokio::fs::create_dir_all(parent).await?;
+        }
+
+        let data = match self.format {
+            ConfigFormat::Toml => toml::to_string(&self.config)?,
+            ConfigFormat::Json => serde_json::to_string_pretty(&self.config)?,
+        };
+
+        let tmp_path = self.path.with_extension("tmp");
+        let mut file = File::create(&tmp_path).await?;
+        file.write_all(data.as_bytes()).await?;
+        file.flush().await?;
+
+        // atomic operation i guess
+        tokio::fs::rename(tmp_path, &self.path).await?;
+
+        Ok(())
+    }
+}
+
+impl ConfigFile {
+    pub async fn get() -> Result<ConfigFile> {
+        let config_file = crate::helpers::directories::get_config_file()?;
+        let mut config_format = ConfigFormat::Json;
+        let config = match fs::read_to_string(&config_file).await {
+            Ok(config) => {
+                if config_file.extension().unwrap() == "toml" {
+                    let mut config: Config = toml::from_str(&config)?;
+                    handle_envars(&mut config)?;
+                    config_format = ConfigFormat::Toml;
+                    config
+                } else {
+                    let mut config: Config = serde_json::from_str(&config)?;
+                    handle_envars(&mut config)?;
+                    config
+                }
+            }
+            Err(_) => Config {
+                enable_nightly_info: None,
+                enable_release_build: None,
+                downloads_location: None,
+                installation_location: None,
+                version_sync_file_location: None,
+                github_mirror: None,
+                rollback_limit: None,
+                add_neovim_binary_to_path: None,
+            },
+        };
+
+        Ok(ConfigFile {
+            path: config_file,
+            format: config_format,
+            config,
+        })
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum ConfigFormat {
+    Toml,
+    Json,
+}
 
 /// Represents the application configuration.
 ///
@@ -17,6 +93,7 @@ use tokio::fs::{self};
 /// * `version_sync_file_location: Option<String>` - The location for the version sync file. This is optional and may be `None`.
 /// * `github_mirror: Option<String>` - The GitHub mirror to use. This is optional and may be `None`.
 /// * `rollback_limit: Option<u8>` - The rollback limit. This is optional and may be `None`.
+/// * `add_neovim_binary_to_path: Option<bool>` - Tells bob whenever to add neovim proxy path to $PATH.
 ///
 /// # Example
 ///
@@ -29,60 +106,28 @@ use tokio::fs::{self};
 ///     version_sync_file_location: Some("/path/to/version_sync_file".to_string()),
 ///     github_mirror: Some("https://github.com".to_string()),
 ///     rollback_limit: Some(5),
+///     rollback_limit: Some(true),
 /// };
 /// println!("The configuration is {:?}", config);
 /// ```
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct Config {
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub enable_nightly_info: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub enable_release_build: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub downloads_location: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub installation_location: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub version_sync_file_location: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub github_mirror: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub rollback_limit: Option<u8>,
-}
-
-/// Handles the application configuration.
-///
-/// This function reads the configuration file, which can be in either TOML or JSON format, and returns a `Config` object. If the configuration file does not exist, it returns a `Config` object with all fields set to `None`.
-///
-/// # Returns
-///
-/// * `Result<Config>` - Returns a `Result` that contains a `Config` object if the function completes successfully. If an error occurs, it returns `Err`.
-///
-/// # Example
-///
-/// ```rust
-/// let config = handle_config().await.unwrap();
-/// println!("The configuration is {:?}", config);
-/// ```
-pub async fn handle_config() -> Result<Config> {
-    let config_file = crate::helpers::directories::get_config_file()?;
-    let config = match fs::read_to_string(&config_file).await {
-        Ok(config) => {
-            if config_file.extension().unwrap() == "toml" {
-                let mut config: Config = toml::from_str(&config)?;
-                handle_envars(&mut config)?;
-                config
-            } else {
-                let mut config: Config = serde_json::from_str(&config)?;
-                handle_envars(&mut config)?;
-                config
-            }
-        }
-        Err(_) => Config {
-            enable_nightly_info: None,
-            enable_release_build: None,
-            downloads_location: None,
-            installation_location: None,
-            version_sync_file_location: None,
-            github_mirror: None,
-            rollback_limit: None,
-        },
-    };
-
-    Ok(config)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub add_neovim_binary_to_path: Option<bool>,
 }
 
 /// Handles environment variables in the configuration.

src/handlers/erase_handler.rs

@@ -2,7 +2,10 @@ use anyhow::{anyhow, Result};
 use tokio::fs;
 use tracing::info;
 
-use crate::{config::Config, helpers::directories};
+use crate::{
+    config::Config,
+    helpers::directories::{self},
+};
 
 /// Starts the erase process based on the provided `Config`.
 ///
@@ -74,7 +77,29 @@ pub async fn start(config: Config) -> Result<()> {
 
                 info!("Successfully removed neovim's installation PATH from registry");
             }
+        } else {
+            use what_the_path::shell::Shell;
+            use crate::helpers::directories::get_downloads_directory;
 
+            let shell = Shell::detect_by_shell_var()?;
+
+            match shell {
+                Shell::Fish(fish) => {
+                    let files = fish.get_rcfiles()?;
+                    let fish_file = files[0].join("bob.fish");
+                    if !fish_file.exists() { return Ok(()) }
+                    fs::remove_file(fish_file).await?;
+                },
+                shell => {
+                    let files = shell.get_rcfiles()?;
+                    let downloads_dir = get_downloads_directory(&config).await?;
+                    let env_path = downloads_dir.join("env/env.sh");
+                    let source_string = format!(". \"{}\"", env_path.display());
+                    for file in files {
+                        what_the_path::shell::remove_from_rcfile(file, &source_string)?;
+                    }
+                }
+            }
         }
     }
 

src/handlers/install_handler.rs

@@ -1,4 +1,4 @@
-use crate::config::Config;
+use crate::config::{Config, ConfigFile};
 use crate::github_requests::{get_commits_for_nightly, get_upstream_nightly, UpstreamVersion};
 use crate::helpers::checksum::sha256cmp;
 use crate::helpers::processes::handle_subprocess;
@@ -64,7 +64,7 @@ use super::{InstallResult, PostDownloadVersionType};
 pub async fn start(
     version: &mut ParsedVersion,
     client: &Client,
-    config: &Config,
+    config: &ConfigFile,
 ) -> Result<InstallResult> {
     if version.version_type == VersionType::NightlyRollback {
         return Ok(InstallResult::GivenNightlyRollback);
@@ -76,13 +76,13 @@ pub async fn start(
         }
     }
 
-    let root = directories::get_downloads_directory(config).await?;
+    let root = directories::get_downloads_directory(&config.config).await?;
 
     env::set_current_dir(&root)?;
     let root = root.as_path();
 
     let is_version_installed =
-        helpers::version::is_version_installed(&version.tag_name, config).await?;
+        helpers::version::is_version_installed(&version.tag_name, &config.config).await?;
 
     if is_version_installed && version.version_type != VersionType::Nightly {
         return Ok(InstallResult::VersionAlreadyInstalled);
@@ -98,15 +98,15 @@ pub async fn start(
         info!("Looking for nightly updates");
 
         let upstream_nightly = nightly_version.as_ref().unwrap();
-        let local_nightly = helpers::version::nightly::get_local_nightly(config).await?;
+        let local_nightly = helpers::version::nightly::get_local_nightly(&config.config).await?;
 
         if upstream_nightly.published_at == local_nightly.published_at {
             return Ok(InstallResult::NightlyIsUpdated);
         }
 
-        handle_rollback(config).await?;
+        handle_rollback(&config.config).await?;
 
-        match config.enable_nightly_info {
+        match config.config.enable_nightly_info {
             Some(boolean) if boolean => {
                 print_commits(client, &local_nightly, upstream_nightly).await?
             }
@@ -117,24 +117,25 @@ pub async fn start(
 
     let downloaded_archive = match version.version_type {
         VersionType::Normal | VersionType::Latest => {
-            download_version(client, version, root, config, false).await
+            download_version(client, version, root, &config.config, false).await
         }
         VersionType::Nightly => {
-            if config.enable_release_build == Some(true) {
-                handle_building_from_source(version, config).await
+            if config.config.enable_release_build == Some(true) {
+                handle_building_from_source(version, &config.config).await
             } else {
-                download_version(client, version, root, config, false).await
+                download_version(client, version, root, &config.config, false).await
             }
         }
-        VersionType::Hash => handle_building_from_source(version, config).await,
+        VersionType::Hash => handle_building_from_source(version, &config.config).await,
         VersionType::NightlyRollback => Ok(PostDownloadVersionType::None),
     }?;
 
     if let PostDownloadVersionType::Standard(downloaded_archive) = downloaded_archive {
         if version.semver.is_some() && version.semver.as_ref().unwrap() <= &Version::new(0, 4, 4) {
             unarchive::start(downloaded_archive).await?
         } else {
-            let downloaded_checksum = download_version(client, version, root, config, true).await?;
+            let downloaded_checksum =
+                download_version(client, version, root, &config.config, true).await?;
 
             if let PostDownloadVersionType::Standard(downloaded_checksum) = downloaded_checksum {
                 let archive_path = root.join(format!(