refactor language to a struct passed to commands

.github/workflows/shelltests.yml

@@ -6,31 +6,42 @@ on:
   pull_request:
     branches: [ main ]
 
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: ${{ github.repository }}-shelltest
+
 jobs:
   run:
     strategy:
       matrix:
         os: ["ubuntu-latest", "macos-latest"]
     runs-on: ${{ matrix.os }}
+    permissions:
+      contents: read
+      packages: write
+      id-token: write
     steps:
     - name: Checkout
       uses: actions/checkout@v4
 
     - name: Install just
       uses: extractions/setup-just@v1
 
-    - uses: haskell-actions/setup@v2
-      with:
-        ghc-version: '9.8'
-        enable-stack: true
-        stack-version: 'latest'
+    - name: Set up Homebrew
+      id: set-up-homebrew
+      uses: Homebrew/actions/setup-homebrew@master
 
     - name: Install shelltestrunner
-      run: stack install shelltestrunner-1.10
+      run: brew install shelltestrunner
 
     - name: Build beamup
       run: cargo build
 
-    - name: Run ShellTests
+    - name: Run Shelltests
+      if: ${{ matrix.os == 'ubuntu-latest' }}
+      run: just shelltests
+
+    - name: Run MacOS ShellTests
+      if: ${{ matrix.os == 'macos-latest' }}
       run: |
-        just shelltests
+        just shelltests-macos

.github/workflows/compile.yml → .github/workflows/windows-compile.yml

@@ -10,7 +10,7 @@ jobs:
   run:
     strategy:
       matrix:
-        os: ["ubuntu-latest", "macos-latest", "windows-latest"]
+        os: ["windows-latest"]
     runs-on: ${{ matrix.os }}
     steps:
     - name: Checkout

Justfile

@@ -16,3 +16,6 @@ in-docker-shelltests: build
 
 shelltests:
     shelltest -c --diff --debug --all shelltests/*.test
+
+shelltests-macos:
+    shelltest -c --diff --debug --all shelltests/macos/*.test

shelltests/installs.test

@@ -22,12 +22,6 @@ v1.4.1
 ls ~/.local/bin/gleam || ls ~/.beamup/bin/gleam
 >>>=0
 
-# test the version is right
-~/.local/bin/gleam --version || ~/.beamup/bin/gleam --version
->>>
-gleam 1.4.1
->>>=0
-
 # try installing the same version again and error
 target/debug/beamup install gleam v1.4.1
 >>>=1

shelltests/macos/install_erlang.test

@@ -0,0 +1,6 @@
+# test an install of erlang on macos
+target/debug/beamup install erlang OTP-27.1
+>>>=0
+
+DEBUG=1 ~/.beamup/bin/erlc
+>>>=0

src/cmd/build.rs

@@ -1,7 +1,7 @@
 use crate::config;
 use crate::git::GitRef;
 use crate::github::download_release_tarball;
-use crate::languages::{get_github_repo, Language};
+use crate::languages::LanguageStruct;
 use color_eyre::{eyre::Result, eyre::WrapErr};
 use console::Emoji;
 use flate2::read::GzDecoder;
@@ -44,29 +44,32 @@ enum BuildStep<'a> {
 }
 
 pub fn run(
-    language: &Language,
+    language: &LanguageStruct,
     git_ref: &GitRef,
     id: &String,
     _repo: &Option<String>,
     force: bool,
     config: &config::Config,
 ) -> Result<String> {
-    debug!("Building {language} from source from git ref={git_ref} with id={id}");
+    debug!(
+        "Building {:?} from source from git ref={git_ref} with id={id}",
+        language.language
+    );
 
-    let release_dir = config::language_release_dir(language, id, force)?;
+    let release_dir = config::language_release_dir(&language.language, id, force)?;
 
     //maybe grab configure options from environment
     let key = "BEAMUP_BUILD_OPTIONS";
     let user_build_options = match env::var(key) {
         Ok(options) => options,
-        _ => config::lookup_default_build_options(language, config),
+        _ => config::lookup_default_build_options(&language.language, config),
     };
 
-    let github_repo = get_github_repo(language);
+    let github_repo = &language.source_repo;
     let release = git_ref.to_string();
 
     let out_dir = TempDir::new(github_repo.repo.as_str())?;
-    let file = download_release_tarball(language, out_dir.path(), &github_repo, &release)?;
+    let file = download_release_tarball(&language.language, out_dir.path(), github_repo, &release)?;
 
     let tar_gz = File::open(&file).wrap_err_with(|| {
         format!(

src/cmd/component_install.rs

@@ -1,6 +1,6 @@
 use crate::components;
-use crate::eyre;
 use crate::github;
+use crate::utils;
 use color_eyre::{eyre::Report, eyre::Result, eyre::WrapErr};
 use flate2::read::GzDecoder;
 use std::fs;
@@ -12,10 +12,10 @@ use zip;
 pub fn run(
     c: &components::Component,
     release: &String,
-    id: &String,
+    _id: &str,
     force: bool,
 ) -> Result<String, Report> {
-    maybe_create_release_dir(c, id, force)?;
+    utils::check_release_dir(&c.release_dir, force)?;
     let release_dir_string = c
         .release_dir
         .clone()
@@ -34,6 +34,8 @@ pub fn run(
         )
     })?;
 
+    utils::maybe_create_release_dir(&c.release_dir, force)?;
+
     // TODO: better ways to check the type than the extension
     let ext = file.extension().map_or("", |e| e.to_str().unwrap_or(""));
     match ext {
@@ -87,24 +89,3 @@ fn set_permissions(to: &PathBuf) -> Result<()> {
 fn set_permissions(_to: &PathBuf) -> Result<()> {
     Ok(())
 }
-
-fn maybe_create_release_dir(c: &components::Component, id: &String, force: bool) -> Result<()> {
-    match c.release_dir.try_exists() {
-        Ok(true) =>
-            match force {
-                true => {
-                    info!("Force enabled. Deleting existing release directory {:?}", c.release_dir);
-                    fs::remove_dir_all(&c.release_dir)?
-                },
-                _ => return Err(eyre!("Release directory for id {id:} already exists. Use `-f true` to delete {:?} and recreate instead of giving this error.", c.release_dir)),
-            }
-        Ok(false) => {},
-        Err(e) => return Err(eyre!(
-            "Unable to check for existence of release directory for id {id}: {e:?}"
-        )),
-    };
-
-    let _ = std::fs::create_dir_all(&c.release_dir);
-
-    Ok(())
-}

src/cmd/install.rs

@@ -1,6 +1,7 @@
-use crate::config;
+//use crate::config;
 use crate::github;
 use crate::languages;
+use crate::utils;
 use color_eyre::{eyre::eyre, eyre::Report, eyre::Result, eyre::WrapErr};
 use flate2::read::GzDecoder;
 use std::fs::File;
@@ -13,16 +14,18 @@ use zip;
 use std::process::ExitStatus;
 
 pub fn run(
-    language: &languages::Language,
-    github_repo: &github::GithubRepo,
+    language: &languages::LanguageStruct,
     release: &str,
-    id: &String,
+    _id: &str,
     _repo: &Option<String>,
     force: bool,
 ) -> Result<String, Report> {
+    let release_dir = &language.release_dir;
+    utils::check_release_dir(release_dir, force)?;
+    let github_repo = &language.binary_repo;
     let out_dir = TempDir::new(github_repo.repo.as_str())?;
-    let asset_name = github::language_asset_name(language, release)?;
-    let file = github::download_asset(&asset_name, out_dir.path(), github_repo, release)?;
+    let asset_name = &language.asset_prefix;
+    let file = github::download_asset(asset_name, out_dir.path(), github_repo, release)?;
     debug!("file {:?} downloaded", file);
     let open_file = File::open(&file).wrap_err_with(|| {
         format!(
@@ -31,34 +34,34 @@ pub fn run(
         )
     })?;
 
-    let release_dir = config::language_release_dir(language, id, force)?;
+    utils::maybe_create_release_dir(release_dir, force)?;
 
     // TODO: better ways to check the type than the extension
     let ext = file.extension().map_or("", |e| e.to_str().unwrap_or(""));
     match ext {
         "exe" => {
-            let release_dir = release_dir.into_os_string().into_string().unwrap();
+            let release_dir = release_dir.clone().into_os_string().into_string().unwrap();
             exe_run(file, release_dir.clone())?;
             Ok(release_dir)
         }
         "zip" => {
             let mut archive = zip::ZipArchive::new(open_file)?;
-            let extract_dir = match language {
+            let extract_dir = match language.language {
                 languages::Language::Gleam => &release_dir.join("bin"),
-                _ => &release_dir,
+                _ => release_dir,
             };
             archive.extract(extract_dir)?;
-            Ok(release_dir.into_os_string().into_string().unwrap())
+            Ok(release_dir.clone().into_os_string().into_string().unwrap())
         }
         _ => {
             let tar = GzDecoder::new(open_file);
             let mut archive = Archive::new(tar);
-            let extract_dir = match language {
+            let extract_dir = match language.language {
                 languages::Language::Gleam => &release_dir.join("bin"),
-                _ => &release_dir,
+                _ => release_dir,
             };
             archive.unpack(extract_dir)?;
-            Ok(release_dir.into_os_string().into_string().unwrap())
+            Ok(release_dir.clone().into_os_string().into_string().unwrap())
         }
     }
 }

src/cmd/releases.rs

@@ -1,7 +1,6 @@
 use crate::github::print_releases;
-use crate::languages::{get_github_repo, Language};
+use crate::languages::LanguageStruct;
 
-pub fn run(language: &Language) {
-    let github_repo = get_github_repo(language);
-    print_releases(&github_repo);
+pub fn run(language: &LanguageStruct) {
+    print_releases(&language.source_repo);
 }

src/github.rs

@@ -1,4 +1,3 @@
-use crate::config;
 use crate::languages::Language;
 use color_eyre::{eyre::eyre, eyre::Report, eyre::Result, eyre::WrapErr};
 use console::{style, Emoji};
@@ -21,46 +20,6 @@ pub struct GithubRepo {
     pub repo: String,
 }
 
-pub fn language_asset_name(language: &Language, tag: &str) -> Result<String> {
-    let asset_name = match language {
-        Language::Gleam => {
-            let suffix = match (std::env::consts::ARCH, std::env::consts::OS) {
-                ("x86_64", "linux") => "x86_64-unknown-linux-musl.tar.gz",
-                ("aarch64", "linux") => "aarch64-unknown-linux-musl.tar.gz",
-                ("x86_64", "macos") => "x86_64-apple-darwin.tar.gz",
-                ("aarch64", "macos") => "aarch64-apple-darwin.tar.gz",
-                ("x86_64", "windows") => "x86_64-pc-windows-msvc.zip",
-                (arch, os) => {
-                    let e: Report =
-                        eyre!("no {language} asset found to support arch:{arch} os:{os}");
-                    return Err(e);
-                }
-            };
-
-            format!("{language}-{tag}-{suffix}")
-        }
-        Language::Erlang => {
-            let vsn = tag.strip_prefix("OTP-").unwrap_or(tag);
-            match (std::env::consts::ARCH, std::env::consts::OS) {
-                ("x86", "windows") => format!("otp_win32_{vsn}.exe"),
-                ("x86_64", "windows") => format!("otp_win64_{vsn}.exe"),
-                (arch, os) => {
-                    let e: Report =
-                        eyre!("no {language} asset found to support arch:{arch} os:{os}");
-                    return Err(e);
-                }
-            }
-        }
-        Language::Elixir => {
-            // find dir of active Erlang
-            let otp_major_vsn = config::get_otp_major_vsn()?;
-            format!("elixir-otp-{otp_major_vsn:}.zip")
-        }
-    };
-
-    Ok(asset_name)
-}
-
 pub fn print_releases(GithubRepo { org, repo }: &GithubRepo) {
     let rt = setup_tokio();
 

src/languages.rs

@@ -1,7 +1,9 @@
+use crate::config;
 use crate::github::GithubRepo;
 use crate::languages;
 use clap::ValueEnum;
 use color_eyre::{eyre::eyre, eyre::Result};
+use std::path::PathBuf;
 use strum::IntoEnumIterator;
 pub mod elixir;
 pub mod erlang;
@@ -78,11 +80,27 @@ impl std::fmt::Display for Language {
     }
 }
 
-pub fn get_github_repo(language: &Language) -> GithubRepo {
-    match language {
-        Language::Gleam => gleam::get_github_repo(),
-        Language::Erlang => erlang::get_github_repo(),
-        Language::Elixir => elixir::get_github_repo(),
+pub struct LanguageStruct {
+    pub language: Language,
+    pub release_dir: PathBuf,
+    pub asset_prefix: String,
+    pub source_repo: GithubRepo,
+    pub binary_repo: GithubRepo,
+    pub bins: Vec<(String, Language)>,
+}
+
+impl LanguageStruct {
+    pub fn new(
+        language: &Language,
+        release: &str,
+        id: &str,
+        config: &config::Config,
+    ) -> Result<Self> {
+        match language {
+            Language::Erlang => erlang::new(release, id, config),
+            Language::Elixir => elixir::new(release, id, config),
+            Language::Gleam => gleam::new(release, id, config),
+        }
     }
 }
 
@@ -92,3 +110,12 @@ pub fn bin_to_language(bin: &str) -> Result<&languages::Language> {
         _ => Err(eyre!("No language to run command {bin} for found")),
     }
 }
+
+pub fn release_dir(language_str: String, id: &String, _config: &config::Config) -> Result<PathBuf> {
+    let release_dir = config::data_dir()?
+        .join("beamup")
+        .join(language_str)
+        .join(id);
+
+    Ok(release_dir)
+}