use language bins for components but not yet for languages

shelltests/installs.test

@@ -34,3 +34,7 @@ target/debug/beamup install -f gleam v1.4.1
 target/debug/beamup install elixir latest
 >>>2 /Error: No default Erlang installation found. Install an Erlang version, like `beamup install erlang latest` or set a default with `beamup default erlang <ID>` first./
 >>>=1
+
+# found a bug in update-links and that it wasn't run in tests so adding
+target/debug/beamup update-links
+>>>=0

src/cmd/component_install.rs

@@ -12,7 +12,6 @@ use zip;
 pub fn run(
     c: &components::Component,
     release: &String,
-    _id: &str,
     force: bool,
 ) -> Result<String, Report> {
     utils::check_release_dir(&c.release_dir, force)?;

src/cmd/install.rs

@@ -1,4 +1,3 @@
-//use crate::config;
 use crate::github;
 use crate::languages;
 use crate::utils;
@@ -16,8 +15,6 @@ use std::process::ExitStatus;
 pub fn run(
     language: &languages::LanguageStruct,
     release: &str,
-    _id: &str,
-    _repo: &Option<String>,
     force: bool,
 ) -> Result<String, Report> {
     let release_dir = &language.release_dir;

src/cmd/update_links.rs

@@ -1,20 +1,25 @@
 use crate::config;
 use crate::languages;
 use crate::links;
+use crate::components;
 use color_eyre::eyre::Result;
 
-pub fn run(maybe_language: Option<&languages::Language>) -> Result<()> {
+pub fn run(maybe_language: Option<&languages::Language>, config: &config::Config) -> Result<()> {
     let bin_dir = config::bin_dir();
     let _ = std::fs::create_dir_all(&bin_dir);
+    let b = languages::bins(config);
 
-    let bins: Vec<_> = if let Some(language) = maybe_language {
-        languages::BIN_MAP
+    if let Some(language) = maybe_language {
+        let bins = b
             .iter()
-            .filter_map(|(a, b)| if *b == *language { Some(a) } else { None })
-            .collect()
+            .filter_map(|(a, b)| if *b == *language { Some(a) } else { None });
+        links::update(bins, &bin_dir)
     } else {
-        languages::BIN_MAP.iter().map(|(a, _)| a).collect()
-    };
+        let bins = b.iter().map(|(a, _)| a);
+        links::update(bins, &bin_dir)?;
 
-    links::update(bins.into_iter(), &bin_dir)
+        // also update component links
+        let bins = components::bins().into_iter().map(|(a, _)| a);
+        links::update(bins, &bin_dir)
+    }
 }

src/config.rs

@@ -118,7 +118,7 @@ fn get_local_id(language_str: String, local_config: &Option<toml::Table>) -> Opt
 }
 
 pub fn get_otp_major_vsn() -> Result<String> {
-    let dir = match install_to_use("erl") {
+    let dir = match install_to_use_by_language(languages::Language::Erlang) {
         Ok(dir) => Ok(dir),
         Err(_) => Err(eyre!("No default Erlang installation found. Install an Erlang version, like `beamup install erlang latest` or set a default with `beamup default erlang <ID>` first.")),
     }?;
@@ -169,10 +169,16 @@ pub fn component_install_to_use(kind: &components::Kind) -> Result<String> {
     lookup_component_install_by_id(id, Some(component_config))
 }
 
-pub fn install_to_use(bin: &str) -> Result<String> {
-    let language = languages::bin_to_language(bin)?;
+
+pub fn install_to_use_by_bin(bin: &str) -> Result<String> {
     let (_, config) = home_config()?;
-    let language_config = get_language_config(language, &config);
+    let language = languages::bin_to_language(bin.to_string(), &config)?;
+    install_to_use_by_language(language)
+}
+
+fn install_to_use_by_language(language: languages::Language) -> Result<String> {
+    let (_, config) = home_config()?;
+    let language_config = get_language_config(&language, &config);
     let local_config = local_config();
     let language_str = language.to_string();
 

src/languages.rs

@@ -9,65 +9,6 @@ pub mod elixir;
 pub mod erlang;
 pub mod gleam;
 
-#[cfg(unix)]
-pub const BIN_MAP: &[(&str, languages::Language)] = &[
-    // Gleam
-    ("gleam", languages::Language::Gleam),
-    // Erlang
-    ("ct_run", languages::Language::Erlang),
-    ("dialyzer", languages::Language::Erlang),
-    ("epmd", languages::Language::Erlang),
-    ("erl", languages::Language::Erlang),
-    ("erlc", languages::Language::Erlang),
-    ("erl_call", languages::Language::Erlang),
-    ("escript", languages::Language::Erlang),
-    ("run_erl", languages::Language::Erlang),
-    ("run_test", languages::Language::Erlang),
-    ("to_erl", languages::Language::Erlang),
-    ("typer", languages::Language::Erlang),
-    // Elixir
-    ("elixir", languages::Language::Elixir),
-    ("elixirc", languages::Language::Elixir),
-    ("iex", languages::Language::Elixir),
-    ("mix", languages::Language::Elixir),
-    ("mix", languages::Language::Elixir),
-];
-
-#[cfg(windows)]
-pub const BIN_MAP: &[(&str, languages::Language)] = &[
-    // Gleam
-    ("gleam.exe", languages::Language::Gleam),
-    // Erlang
-    ("ct_run.exe", languages::Language::Erlang),
-    ("dialyzer.exe", languages::Language::Erlang),
-    ("epmd.exe", languages::Language::Erlang),
-    ("erl.exe", languages::Language::Erlang),
-    ("erlc.exe", languages::Language::Erlang),
-    ("erl_call.exe", languages::Language::Erlang),
-    ("escript.exe", languages::Language::Erlang),
-    ("run_erl.exe", languages::Language::Erlang),
-    ("run_test.exe", languages::Language::Erlang),
-    ("to_erl.exe", languages::Language::Erlang),
-    ("typer.exe", languages::Language::Erlang),
-    ("ct_run", languages::Language::Erlang),
-    ("dialyzer", languages::Language::Erlang),
-    ("epmd", languages::Language::Erlang),
-    ("erl", languages::Language::Erlang),
-    ("erlc", languages::Language::Erlang),
-    ("erl_call", languages::Language::Erlang),
-    ("escript", languages::Language::Erlang),
-    ("run_erl", languages::Language::Erlang),
-    ("run_test", languages::Language::Erlang),
-    ("to_erl", languages::Language::Erlang),
-    ("typer", languages::Language::Erlang),
-    // Elixir
-    ("elixir.bat", languages::Language::Elixir),
-    ("elixirc.bat", languages::Language::Elixir),
-    ("iex.bat", languages::Language::Elixir),
-    ("mix.bat", languages::Language::Elixir),
-    ("mix.ps1", languages::Language::Elixir),
-];
-
 #[derive(ValueEnum, Debug, Clone, PartialEq, EnumIter)]
 pub enum Language {
     Elixir,
@@ -91,6 +32,20 @@ impl std::fmt::Display for Language {
     }
 }
 
+pub fn bins(_config: &config::Config) -> Vec<(String, Language)> {
+    let mut bins = vec![];
+    let mut elixir_bins = elixir::bins();
+    let mut erlang_bins = erlang::bins();
+    let mut gleam_bins = gleam::bins();
+
+    bins.append(&mut elixir_bins);
+    bins.append(&mut erlang_bins);
+    bins.append(&mut gleam_bins);
+
+    bins
+}
+
+#[allow(dead_code)]
 pub struct LanguageStruct {
     pub language: Language,
     pub release_dir: PathBuf,
@@ -116,9 +71,9 @@ impl LanguageStruct {
     }
 }
 
-pub fn bin_to_language(bin: &str) -> Result<&languages::Language> {
-    match languages::BIN_MAP.iter().find(|&(k, _)| *k == bin) {
-        Some((_, language)) => Ok(language),
+pub fn bin_to_language(bin: String, config: &config::Config) -> Result<languages::Language> {
+    match bins(config).iter().find(|&(k, _)| *k == bin) {
+        Some((_, language)) => Ok(language.clone()),
         _ => Err(eyre!("No language to run command {bin} for found")),
     }
 }

src/languages/elixir.rs

@@ -11,6 +11,7 @@ pub fn new(release: &str, id: &str, config: &config::Config) -> Result<LanguageS
         language: Language::Elixir,
         release_dir: languages::release_dir(LANGUAGE_STRING.to_string(), &id.to_string(), config)?,
         extract_dir: languages::release_dir(LANGUAGE_STRING.to_string(), &id.to_string(), config)?,
+        // TODO: make this into a closure or method so we only have to run it when we need the asset
         asset_prefix: asset_prefix(release, config)?,
         source_repo: get_source_github_repo(release, config),
         binary_repo: get_binary_github_repo(release, config),
@@ -19,7 +20,7 @@ pub fn new(release: &str, id: &str, config: &config::Config) -> Result<LanguageS
 }
 
 #[cfg(unix)]
-fn bins() -> Vec<(String, languages::Language)> {
+pub fn bins() -> Vec<(String, languages::Language)> {
     vec![
         ("elixir".to_string(), languages::Language::Elixir),
         ("elixirc".to_string(), languages::Language::Elixir),
@@ -29,7 +30,7 @@ fn bins() -> Vec<(String, languages::Language)> {
 }
 
 #[cfg(windows)]
-fn bins() -> Vec<(String, languages::Language)> {
+pub fn bins() -> Vec<(String, languages::Language)> {
     vec![
         ("elixir.bat".to_string(), languages::Language::Elixir),
         ("elixirc.bat".to_string(), languages::Language::Elixir),

src/languages/erlang.rs

@@ -19,7 +19,7 @@ pub fn new(release: &str, id: &str, config: &config::Config) -> Result<LanguageS
 }
 
 #[cfg(unix)]
-fn bins() -> Vec<(String, languages::Language)> {
+pub fn bins() -> Vec<(String, languages::Language)> {
     vec![
         ("ct_run".to_string(), languages::Language::Erlang),
         ("dialyzer".to_string(), languages::Language::Erlang),
@@ -36,7 +36,7 @@ fn bins() -> Vec<(String, languages::Language)> {
 }
 
 #[cfg(windows)]
-fn bins() -> Vec<(String, languages::Language)> {
+pub fn bins() -> Vec<(String, languages::Language)> {
     vec![
         ("ct_run.exe".to_string(), languages::Language::Erlang),
         ("dialyzer.exe".to_string(), languages::Language::Erlang),

src/languages/gleam.rs

@@ -19,14 +19,14 @@ pub fn new(release: &str, id: &str, config: &config::Config) -> Result<LanguageS
 }
 
 #[cfg(unix)]
-fn bins() -> Vec<(String, languages::Language)> {
+pub fn bins() -> Vec<(String, languages::Language)> {
     vec![
         ("gleam".to_string(), languages::Language::Gleam),
     ]
 }
 
 #[cfg(windows)]
-fn bins() -> Vec<(String, languages::Language)> {
+pub fn bins() -> Vec<(String, languages::Language)> {
     vec![
         ("gleam.exe".to_string(), languages::Language::Gleam),
         ("gleam".to_string(), languages::Language::Gleam),

src/main.rs

@@ -283,6 +283,7 @@ fn print_completions<G: Generator>(gen: G, cmd: &mut Command) {
 }
 
 fn handle_command(_bin_path: PathBuf) -> Result<(), Report> {
+
     let cli = Cli::parse();
 
     let (config_file, config) = match &cli.config {
@@ -347,8 +348,8 @@ fn handle_command(_bin_path: PathBuf) -> Result<(), Report> {
 
             let language_struct = languages::LanguageStruct::new(language, release, id, &config)?;
 
-            let dir = cmd::install::run(&language_struct, release, id, repo, *force)?;
-            cmd::update_links::run(Some(language))?;
+            let dir = cmd::install::run(&language_struct, release, *force)?;
+            cmd::update_links::run(Some(language), &config)?;
 
             config::add_install(language, id, release, dir, config_file, config)?;
 
@@ -362,7 +363,7 @@ fn handle_command(_bin_path: PathBuf) -> Result<(), Report> {
         SubCommands::UpdateLinks => {
             debug!("running update-links");
 
-            cmd::update_links::run(None)?;
+            cmd::update_links::run(None, &config)?;
 
             info!("Updated links of language binaries to current beamup install");
 
@@ -427,7 +428,7 @@ fn handle_command(_bin_path: PathBuf) -> Result<(), Report> {
             info!("Building {:?} for ref={} id={}", language, git_ref, id);
             let dir = cmd::build::run(&language_struct, &git_ref, &id, repo, *force, &config)?;
 
-            cmd::update_links::run(Some(language))?;
+            cmd::update_links::run(Some(language), &config)?;
 
             config::add_install(
                 language,
@@ -465,7 +466,7 @@ fn handle_command(_bin_path: PathBuf) -> Result<(), Report> {
 
             let c = components::Component::new(component.clone(), release)?;
 
-            let release_dir = cmd::component_install::run(&c, release, id, *force)?;
+            let release_dir = cmd::component_install::run(&c, release, *force)?;
 
             let bin_dir = config::bin_dir();
             let _ = std::fs::create_dir_all(&bin_dir);
@@ -566,7 +567,8 @@ fn main() -> Result<(), Report> {
             }
         }
     } else {
-        match languages::BIN_MAP.iter().find(|&(k, _)| *k == f) {
+        let (_, config) = config::home_config()?;
+        match languages::bins(&config).iter().find(|&(k, _)| *k == f.to_str().unwrap()) {
             Some((c, _)) => {
                 let bin = Path::new(c).file_name().unwrap();
                 run::run(bin.to_str().unwrap(), args)

src/run.rs

@@ -28,7 +28,7 @@ pub fn run_component(bin: &str, kind: &components::Kind, args: Args) -> Result<(
 
 pub fn run(bin: &str, args: Args) -> Result<()> {
     // no -c argument available in this case
-    let dir = config::install_to_use(bin)?;
+    let dir = config::install_to_use_by_bin(bin)?;
     let cmd = Path::new(bin);
 
     debug!("running language command {:?}", cmd);