feat: add support to shell expansion

Author: helton

Cargo.lock

@@ -12,3 +12,4 @@ colored = "2.1.0"
 serde = { version = "1.0.201", features = ["derive"] }
 serde_json = "1.0.117"
 atty = "0.2.14"
+shellexpand = "3.1.0"

Cargo.toml

@@ -56,6 +56,7 @@ enum Commands {
     },
 
     /// Run the package
+    #[command(disable_help_flag = true)]
     Run {
         /// Name of the package to run
         name: String,

src/cli.rs

@@ -2,7 +2,7 @@ use crate::files::versions::{remove, upsert};
 use crate::packages;
 use crate::packages::Package;
 use crate::runner::run;
-use crate::shims::add_shim;
+use crate::shims::{add_shim, remove_shim};
 use colored::*;
 use std::env;
 use std::error::Error;
@@ -46,7 +46,7 @@ pub fn list_packages(name: Option<&str>) -> Result<(), Box<dyn Error>> {
             }
             Ok(())
         } else {
-            Err(Box::from("Could not find any packages installed."))
+            Err("Could not find any packages installed.".into())
         }
     }
 }
@@ -61,10 +61,13 @@ pub fn add_package(name: String, version: String, set_default: bool) -> Result<(
         if set_default {
             package.versions.current = version.clone();
         }
-        run_pull_and_add_shim(&name, &version, package)?;
+        let current = package.versions.current.clone();
+        do_add_package(&name, &version, package)?;
+        println!("Added '{}' version '{}'. Current version is '{}'.", name, version, current);
     } else {
         let package = Package::new(&name, crate::files::versions::Package::new(&version))?;
-        run_pull_and_add_shim(&name, &version, package)?;
+        do_add_package(&name, &version, package)?;
+        println!("Added '{}' version '{}'. Current version is '{}'.", name, version, version);
     }
     Ok(())
 }
@@ -82,7 +85,7 @@ pub fn remove_package(name: String, version: Option<String>) -> Result<(), Box<d
                 if package.versions.versions.contains(&version) {
                     package.versions.versions.retain(|v| v != version.as_str());
                     if package.versions.versions.is_empty() {
-                        remove(&name)?;
+                        do_remove_package(&name)?;
                         println!("Removed package '{}'.", name);
                     } else {
                         upsert(&name, package)?;
@@ -95,7 +98,8 @@ pub fn remove_package(name: String, version: Option<String>) -> Result<(), Box<d
             }
         }
         (Some(_), None) => {
-            remove(&name)?;
+            do_remove_package(&name)?;
+            println!("Removed package '{}'.", name);
             Ok(())
         }
         (None, _) => Err(format!("Package '{}' does not exists.", name).into()),
@@ -130,11 +134,7 @@ pub fn run_package(name: String, subcommand: Vec<String>) -> Result<(), Box<dyn
     }
 }
 
-fn run_pull_and_add_shim(
-    name: &String,
-    version: &String,
-    package: Package,
-) -> Result<(), Box<dyn Error>> {
+fn do_add_package(name: &String, version: &String, package: Package) -> Result<(), Box<dyn Error>> {
     let mut new_package = package.clone();
     new_package.versions.current = version.clone();
     if crate::runner::pull(&new_package) {
@@ -145,3 +145,9 @@ fn run_pull_and_add_shim(
         Err(format!("Failed to add package '{}' at version '{}'.", name, version).into())
     }
 }
+
+fn do_remove_package(name: &String) -> Result<(), Box<dyn Error>> {
+    remove(&name)?;
+    remove_shim(&name)?;
+    Ok(())
+}

src/commands.rs

@@ -49,12 +49,20 @@ impl Package {
     }
 
     pub fn print(&self) {
-        println!("- {}", self.name);
+        println!("- [{}]", self.name);
+        println!("  - image: {}", self.index.image);
+        if let Some(volumes) = &self.index.volumes {
+            println!("  - volumes:");
+            for volume in volumes {
+                println!("    - {}:{}", volume.source, volume.target);
+            }
+        }
+        println!("  - versions:");
         for version in &self.versions.versions {
             if version == &self.versions.current {
-                println!("  - {} ✔", version);
+                println!("    - {} ✔", version);
             } else {
-                println!("  - {}", version);
+                println!("    - {}", version);
             }
         }
     }

src/packages.rs

@@ -1,6 +1,7 @@
 use crate::packages::Package;
 use atty::Stream;
 use std::io::{self, Read, Write};
+use std::path::Path;
 use std::process::{Command, Stdio};
 
 fn run_command(command: &str, stdin_buffer: Option<Vec<u8>>) -> bool {
@@ -44,22 +45,39 @@ pub fn run(package: &Package, params: &Vec<String>) -> bool {
         io::stdin()
             .read_to_end(&mut buffer)
             .expect("Failed to read stdin");
-        buffer.len();
     }
 
-    let interactive_flag = if interactive { "-i " } else { "" };
-    let command = format!(
-        "docker run {}{} {}",
-        interactive_flag,
-        package.container_image_url(),
-        params.join(" ")
-    );
+    let mut args = vec!["run".to_string()];
+    if interactive {
+        args.push("-i".to_string());
+    }
+
+    // Handling volumes if available
+    if let Some(volumes) = &package.index.volumes {
+        for volume in volumes {
+            let source = shellexpand::full(&volume.source).unwrap();
+            if Path::new(&source.to_string()).exists() {
+                args.push("-v".to_string());
+                args.push(format!("{}:{}", &source, volume.target));
+            } else {
+                println!("Volume source '{}' not found. Skipping.", source);
+            }
+        }
+    }
+
+    args.push(format!(
+        "{}:{}",
+        package.index.image.clone(),
+        package.versions.current
+    ));
+    args.extend(params.iter().cloned());
 
+    let command = format!("docker {}", args.join(" "));
+    println!("Running {}", command);
     run_command(&command, Some(buffer))
 }
 
 pub fn pull(package: &Package) -> bool {
     let command = format!("docker pull {}", package.container_image_url());
-    // Normally, pull does not need stdin interaction
     run_command(&command, None)
 }