config: added rwlock around plugins map

src/cli/current.rs

@@ -25,13 +25,11 @@ impl Current {
         match &self.plugin {
             Some(plugin_name) => {
                 let plugin_name = unalias_plugin(plugin_name);
-                match config.plugins.get(plugin_name) {
-                    Some(plugin) => self.one(&config, ts, out, plugin.clone()),
-                    None => {
-                        warn!("Plugin {} is not installed", plugin_name);
-                        Ok(())
-                    }
+                let plugin = config.get_or_create_plugin(plugin_name);
+                if !plugin.is_installed() {
+                    bail!("Plugin {} is not installed", plugin_name);
                 }
+                self.one(&config, ts, out, plugin.clone())
             }
             None => self.all(&config, ts, out),
         }

src/cli/doctor.rs

@@ -45,7 +45,7 @@ impl Doctor {
         );
 
         let mut checks = Vec::new();
-        for plugin in config.plugins.values() {
+        for plugin in config.list_plugins() {
             if !plugin.is_installed() {
                 checks.push(format!("plugin {} is not installed", &plugin.name()));
                 continue;
@@ -123,8 +123,8 @@ fn render_config_files(config: &Config) -> String {
 fn render_plugins(config: &Config) -> String {
     let mut s = style("plugins:\n").bold().to_string();
     let plugins = config
-        .plugins
-        .values()
+        .list_plugins()
+        .into_iter()
         .filter(|p| p.is_installed())
         .collect::<Vec<_>>();
     let max_plugin_name_len = plugins.iter().map(|p| p.name().len()).max().unwrap_or(0) + 2;

src/cli/external.rs

@@ -1,26 +1,19 @@
 use clap::{ArgMatches, Command};
 use color_eyre::eyre::Result;
-use itertools::Itertools;
 use rayon::prelude::*;
 
 use crate::config::Config;
 
 pub fn commands(config: &Config) -> Vec<Command> {
     config
-        .plugins
-        .values()
-        .collect_vec()
+        .list_plugins()
         .into_par_iter()
-        .flat_map(|p| match p.external_commands() {
-            Ok(commands) => commands,
-            Err(e) => {
-                warn!(
-                    "failed to load external commands for plugin {}: {:#}",
-                    p.name(),
-                    e
-                );
+        .flat_map(|p| {
+            p.external_commands().unwrap_or_else(|e| {
+                let p = p.name();
+                warn!("failed to load external commands for plugin {p}: {e:#}");
                 vec![]
-            }
+            })
         })
         .collect()
 }
@@ -36,7 +29,7 @@ pub fn execute(
         .find(|c| c.get_name() == plugin)
     {
         if let Some((subcommand, matches)) = args.subcommand() {
-            let plugin = config.plugins.get(&plugin.to_string()).unwrap();
+            let plugin = config.get_or_create_plugin(plugin);
             let args: Vec<String> = matches
                 .get_raw("args")
                 .unwrap_or_default()

src/cli/install.rs

@@ -53,12 +53,12 @@ impl Install {
             warn!("specify a version with `rtx install <PLUGIN>@<VERSION>`");
             return Ok(());
         }
-        ts.install_versions(&mut config, tool_versions, &mpr, self.force)
+        ts.install_versions(&config, tool_versions, &mpr, self.force)
     }
 
     fn get_requested_tool_versions(
         &self,
-        config: &mut Config,
+        config: &Config,
         ts: &Toolset,
         runtimes: &[ToolArg],
         mpr: &MultiProgressReport,
@@ -102,10 +102,10 @@ impl Install {
         Ok(tool_versions)
     }
 
-    fn install_missing_runtimes(&self, mut config: Config) -> Result<()> {
+    fn install_missing_runtimes(&self, config: Config) -> Result<()> {
         let mut ts = ToolsetBuilder::new()
             .with_latest_versions()
-            .build(&mut config)?;
+            .build(&config)?;
         let versions = ts
             .list_missing_versions(&config)
             .into_iter()
@@ -116,7 +116,7 @@ impl Install {
             return Ok(());
         }
         let mpr = MultiProgressReport::new(&config.settings);
-        ts.install_versions(&mut config, versions, &mpr, self.force)?;
+        ts.install_versions(&config, versions, &mpr, self.force)?;
         Ok(())
     }
 }

src/cli/link.rs

@@ -33,7 +33,7 @@ pub struct Link {
 }
 
 impl Link {
-    pub fn run(self, mut config: Config, _out: &mut Output) -> Result<()> {
+    pub fn run(self, config: Config, _out: &mut Output) -> Result<()> {
         let version = match self.tool.tvr {
             Some(ref tvr) => tvr.version(),
             None => {

src/cli/ls.rs

@@ -94,8 +94,8 @@ impl Ls {
     fn verify_plugin(&self, config: &Config) -> Result<()> {
         match &self.plugin {
             Some(plugin_name) => {
-                let plugin = config.plugins.get(plugin_name);
-                if plugin.is_none() || !plugin.unwrap().is_installed() {
+                let plugin = config.get_or_create_plugin(plugin_name);
+                if !plugin.is_installed() {
                     return Err(PluginNotInstalled(plugin_name.clone()))?;
                 }
             }
@@ -209,12 +209,11 @@ impl Ls {
         Ok(())
     }
 
-    fn get_runtime_list(&self, config: &mut Config) -> Result<Vec<RuntimeRow>> {
+    fn get_runtime_list(&self, config: &Config) -> Result<Vec<RuntimeRow>> {
         let mut tsb = ToolsetBuilder::new().with_global_only(self.global);
 
         if let Some(plugin) = &self.plugin {
             tsb = tsb.with_tools(&[plugin]);
-            config.plugins.retain(|p, _| p == plugin);
         }
         let ts = tsb.build(config)?;
         let mut versions: HashMap<(String, String), (Arc<dyn Plugin>, ToolVersion)> = ts
@@ -233,6 +232,10 @@ impl Ls {
 
         let rvs: Vec<RuntimeRow> = versions
             .into_iter()
+            .filter(|((plugin_name, _), _)| match &self.plugin {
+                Some(p) => p.eq(plugin_name),
+                None => true,
+            })
             .sorted_by_cached_key(|((plugin_name, version), _)| {
                 (
                     plugin_name.clone(),

src/cli/ls_remote.rs

@@ -68,9 +68,8 @@ impl LsRemote {
 
     fn run_all(self, config: Config, out: &mut Output) -> Result<()> {
         let versions = config
-            .plugins
-            .values()
-            .par_bridge()
+            .list_plugins()
+            .into_par_iter()
             .map(|p| {
                 let versions = p.list_remote_versions(&config.settings)?;
                 Ok((p, versions))
@@ -87,7 +86,7 @@ impl LsRemote {
         Ok(())
     }
 
-    fn get_plugin(&self, config: &mut Config) -> Result<Option<Arc<dyn Plugin>>> {
+    fn get_plugin(&self, config: &Config) -> Result<Option<Arc<dyn Plugin>>> {
         match &self.plugin {
             Some(tool_arg) => {
                 let plugin = config.get_or_create_plugin(&tool_arg.plugin);

src/cli/plugins/install.rs

@@ -105,7 +105,7 @@ impl PluginsInstall {
 
     fn install_one(
         &self,
-        config: &mut Config,
+        config: &Config,
         name: PluginName,
         git_url: Option<String>,
         mpr: &MultiProgressReport,

src/cli/plugins/ls.rs

@@ -43,7 +43,7 @@ pub struct PluginsLs {
 
 impl PluginsLs {
     pub fn run(self, config: Config, out: &mut Output) -> Result<()> {
-        let mut tools = config.plugins.values().cloned().collect::<BTreeSet<_>>();
+        let mut tools = config.list_plugins().into_iter().collect::<BTreeSet<_>>();
 
         if self.all {
             for (plugin, url) in config.get_shorthands() {

src/cli/plugins/ls_remote.rs

@@ -25,10 +25,10 @@ pub struct PluginsLsRemote {
 impl PluginsLsRemote {
     pub fn run(self, config: Config, out: &mut Output) -> Result<()> {
         let installed_plugins = config
-            .plugins
-            .values()
+            .list_plugins()
+            .into_iter()
             .filter(|p| p.is_installed())
-            .map(|p| p.name())
+            .map(|p| p.name().to_string())
             .collect::<HashSet<_>>();
 
         let shorthands = config.get_shorthands().iter().sorted().collect_vec();

src/cli/plugins/uninstall.rs

@@ -28,7 +28,11 @@ impl PluginsUninstall {
         let mpr = MultiProgressReport::new(&config.settings);
 
         let plugins = match self.all {
-            true => config.plugins.keys().cloned().collect(),
+            true => config
+                .list_plugins()
+                .into_iter()
+                .map(|p| p.name().to_string())
+                .collect(),
             false => self.plugin.clone(),
         };
 
@@ -45,8 +49,8 @@ impl PluginsUninstall {
         plugin_name: &str,
         mpr: &MultiProgressReport,
     ) -> Result<()> {
-        match config.plugins.get(plugin_name) {
-            Some(plugin) if plugin.is_installed() => {
+        match config.get_or_create_plugin(plugin_name) {
+            plugin if plugin.is_installed() => {
                 let mut pr = mpr.add();
                 plugin.decorate_progress_bar(&mut pr, None);
                 plugin.uninstall(&pr)?;

src/cli/plugins/update.rs

@@ -1,5 +1,4 @@
-use color_eyre::eyre::{eyre, Result};
-use console::style;
+use color_eyre::eyre::Result;
 
 use crate::config::Config;
 use crate::output::Output;
@@ -31,9 +30,7 @@ impl Update {
                         None => (p.as_str(), None),
                     };
                     let p = unalias_plugin(p);
-                    let plugin = config.plugins.get(p).ok_or_else(|| {
-                        eyre!("plugin {} not found", style(p).cyan().for_stderr())
-                    })?;
+                    let plugin = config.get_or_create_plugin(p);
                     Ok((plugin.clone(), ref_))
                 })
                 .collect::<Result<_>>()?,

src/cli/prune.rs

@@ -44,7 +44,7 @@ impl Prune {
 
         for cf in config.get_tracked_config_files()?.values() {
             let mut ts = cf.to_toolset().clone();
-            ts.resolve(&mut config);
+            ts.resolve(&config);
             for (_, tv) in ts.list_current_versions(&config) {
                 to_delete.remove(&tv.to_string());
             }

src/cli/sync/node.rs

@@ -48,7 +48,7 @@ impl SyncNode {
         Ok(())
     }
 
-    fn run_brew(self, mut config: Config, out: &mut Output) -> Result<()> {
+    fn run_brew(self, config: Config, out: &mut Output) -> Result<()> {
         let tool = config.get_or_create_plugin(&PluginName::from("node"));
 
         let brew_prefix = PathBuf::from(cmd!("brew", "--prefix").read()?).join("opt");
@@ -69,7 +69,7 @@ impl SyncNode {
         config.rebuild_shims_and_runtime_symlinks()
     }
 
-    fn run_nvm(self, mut config: Config, out: &mut Output) -> Result<()> {
+    fn run_nvm(self, config: Config, out: &mut Output) -> Result<()> {
         let tool = config.get_or_create_plugin(&PluginName::from("node"));
 
         let nvm_versions_path = NVM_DIR.join("versions").join("node");
@@ -87,7 +87,7 @@ impl SyncNode {
         config.rebuild_shims_and_runtime_symlinks()
     }
 
-    fn run_nodenv(self, mut config: Config, out: &mut Output) -> Result<()> {
+    fn run_nodenv(self, config: Config, out: &mut Output) -> Result<()> {
         let tool = config.get_or_create_plugin(&PluginName::from("node"));
 
         let nodenv_versions_path = NODENV_ROOT.join("versions");

src/cli/sync/python.rs

@@ -20,7 +20,7 @@ pub struct SyncPython {
 }
 
 impl SyncPython {
-    pub fn run(self, mut config: Config, out: &mut Output) -> Result<()> {
+    pub fn run(self, config: Config, out: &mut Output) -> Result<()> {
         let python = config.get_or_create_plugin(&PluginName::from("python"));
 
         let pyenv_versions_path = PYENV_ROOT.join("versions");

src/cli/upgrade.rs

@@ -51,7 +51,7 @@ impl Upgrade {
         Ok(())
     }
 
-    fn upgrade(&self, config: &mut Config, outdated: OutputVec, out: &mut Output) -> Result<()> {
+    fn upgrade(&self, config: &Config, outdated: OutputVec, out: &mut Output) -> Result<()> {
         let mpr = MultiProgressReport::new(&config.settings);
         let mut ts = ToolsetBuilder::new().with_args(&self.tool).build(config)?;
 

src/cli/where.rs

@@ -2,7 +2,7 @@ use color_eyre::eyre::Result;
 
 use crate::cli::args::tool::{ToolArg, ToolArgParser};
 use crate::config::Config;
-use crate::errors::Error::{PluginNotInstalled, VersionNotInstalled};
+use crate::errors::Error::VersionNotInstalled;
 use crate::output::Output;
 use crate::toolset::ToolsetBuilder;
 
@@ -47,10 +47,7 @@ impl Where {
             _ => self.tool,
         };
 
-        let plugin = match config.plugins.get(&runtime.plugin) {
-            Some(plugin) => plugin,
-            None => Err(PluginNotInstalled(runtime.plugin.clone()))?,
-        };
+        let plugin = config.get_or_create_plugin(&runtime.plugin);
 
         match runtime
             .tvr

src/cli/which.rs

@@ -46,7 +46,7 @@ impl Which {
             None => Err(eyre!("{} not found", self.bin_name)),
         }
     }
-    fn get_toolset(&self, config: &mut Config) -> Result<Toolset> {
+    fn get_toolset(&self, config: &Config) -> Result<Toolset> {
         let mut tsb = ToolsetBuilder::new();
         if let Some(tool) = &self.tool {
             tsb = tsb.with_args(&[tool.clone()]);

src/config/config_file/mod.rs

@@ -65,12 +65,7 @@ pub trait ConfigFile: Debug + Display + Send + Sync {
 }
 
 impl dyn ConfigFile {
-    pub fn add_runtimes(
-        &mut self,
-        config: &mut Config,
-        runtimes: &[ToolArg],
-        pin: bool,
-    ) -> Result<()> {
+    pub fn add_runtimes(&mut self, config: &Config, runtimes: &[ToolArg], pin: bool) -> Result<()> {
         // TODO: this has become a complete mess and could probably be greatly simplified
         let mpr = MultiProgressReport::new(&config.settings);
         let mut ts = self.to_toolset().to_owned();
@@ -104,7 +99,7 @@ impl dyn ConfigFile {
                 .into_iter()
                 .map(|tvr| {
                     if pin {
-                        let plugin = config.plugins.get(&plugin).unwrap();
+                        let plugin = config.get_or_create_plugin(&plugin);
                         let tv = tvr.resolve(
                             config,
                             plugin.clone(),