cargo fmt

lib/cli/src/cli.rs

@@ -260,8 +260,9 @@ fn parse_cli_args() -> Result<(), anyhow::Error> {
                         &package.registry,
                         &package.name,
                         &package.version,
-                    ).map_err(|e| anyhow!("{e}"))?;
+                    )
-                    
+                    .map_err(|e| anyhow!("{e}"))?;
+
                     // Try finding the local package
                     let mut args_without_package = args.clone();
                     args_without_package.remove(1);

lib/cli/src/commands/run.rs

@@ -76,18 +76,21 @@ pub struct RunWithoutFile {
 impl RunWithoutFile {
     /// Given a local path, returns the `Run` command (overriding the `--path` argument).
     pub fn into_run_args(mut self, pathbuf: PathBuf, manifest: Option<wapm_toml::Manifest>) -> Run {
-        
+        #[cfg(feature = "wasi")]
-        #[cfg(feature = "wasi")] {
+        {
             let pkg_fs = match pathbuf.parent() {
                 Some(parent) => parent.join("pkg_fs"),
                 None => pathbuf.join("pkg_fs"),
             };
-            if let Some(mut m) = manifest.as_ref().and_then(|m| m.package.pkg_fs_mount_point.clone()) {
+            if let Some(mut m) = manifest
+                .as_ref()
+                .and_then(|m| m.package.pkg_fs_mount_point.clone())
+            {
                 if m == "." {
                     self.wasi.map_dir("/", pkg_fs);
                 } else {
-                    if m.starts_with(".") { 
+                    if m.starts_with(".") {
-                        m = format!("{}{}", pkg_fs.display(), &m[1..]); 
+                        m = format!("{}{}", pkg_fs.display(), &m[1..]);
                     }
                     let path = std::path::Path::new(&m).to_path_buf();
                     self.wasi.map_dir("/", path);
@@ -108,7 +111,10 @@ impl RunWithoutFile {
                     pathbuf.join(real_dir)
                 };
                 if !real_dir.exists() {
-                    println!("warning: cannot map {alias:?} to {}: directory does not exist", real_dir.display());
+                    println!(
+                        "warning: cannot map {alias:?} to {}: directory does not exist",
+                        real_dir.display()
+                    );
                     continue;
                 }
                 let alias_pathbuf = std::path::Path::new(&real_dir).to_path_buf();
@@ -123,11 +129,16 @@ impl RunWithoutFile {
                 }
 
                 let root_display = format!("{}", alias_pathbuf.display());
-                for entry in walkdir::WalkDir::new(&alias_pathbuf).into_iter().filter_entry(|e| is_dir(e)).filter_map(|e| e.ok()) {
+                for entry in walkdir::WalkDir::new(&alias_pathbuf)
+                    .into_iter()
+                    .filter_entry(|e| is_dir(e))
+                    .filter_map(|e| e.ok())
+                {
                     let pathbuf = entry.path().canonicalize().unwrap();
                     let path = format!("{}", pathbuf.display());
                     let relativepath = path.replacen(&root_display, "", 1);
-                    self.wasi.map_dir(&format!("/{alias}{relativepath}"), pathbuf);
+                    self.wasi
+                        .map_dir(&format!("/{alias}{relativepath}"), pathbuf);
                 }
             }
         }
@@ -279,8 +290,10 @@ impl Run {
                 let env = FunctionEnv::new(&mut store, em_env);
                 let mut emscripten_globals = EmscriptenGlobals::new(&mut store, &env, &module)
                     .map_err(|e| anyhow!("{}", e))?;
-                env.as_mut(&mut store)
+                env.as_mut(&mut store).set_data(
-                    .set_data(&emscripten_globals.data, self.wasi.mapped_dirs.clone().into_iter().collect());
+                    &emscripten_globals.data,
+                    self.wasi.mapped_dirs.clone().into_iter().collect(),
+                );
                 let import_object =
                     generate_emscripten_env(&mut store, &env, &mut emscripten_globals);
                 let mut instance = match Instance::new(&mut store, &module, &import_object) {

lib/cli/src/commands/run/wasi.rs

@@ -52,10 +52,10 @@ pub struct Wasi {
 
 #[allow(dead_code)]
 impl Wasi {
-
     pub fn map_dir(&mut self, alias: &str, target_on_disk: PathBuf) {
         self.mapped_dirs.push((alias.to_string(), target_on_disk));
-        self.pre_opened_directories.push(std::path::Path::new(alias).to_path_buf());
+        self.pre_opened_directories
+            .push(std::path::Path::new(alias).to_path_buf());
     }
 
     pub fn set_env(&mut self, key: &str, value: &str) {

lib/emscripten/src/env/unix/mod.rs

@@ -1,7 +1,5 @@
 /// NOTE: These syscalls only support wasm_32 for now because they take u32 offset
-use libc::{
+use libc::{c_int, getgrnam as libc_getgrnam, getpwnam as libc_getpwnam, sysconf};
-    c_int, getgrnam as libc_getgrnam, getpwnam as libc_getpwnam, sysconf,
-};
 use std::ffi::{CStr, CString};
 use std::mem;
 use std::os::raw::c_char;
@@ -29,7 +27,7 @@ pub fn _getenv(mut ctx: FunctionEnvMut<EmEnv>, name: i32) -> u32 {
         Some(s) => s,
         None => return 0,
     };
-    let new_env_var =  match CString::new(env_var) {
+    let new_env_var = match CString::new(env_var) {
         Ok(s) => s,
         Err(_) => return 0,
     };
@@ -52,7 +50,7 @@ pub fn _setenv(ctx: FunctionEnvMut<EmEnv>, name: c_int, value: c_int, overwrite:
     debug!("=> value({:?})", value);
 
     let previous_entry = em_env.set_env_var(name.as_ref(), value.as_ref());
-    
+
     if let (0, Some(prev)) = (overwrite, previous_entry) {
         let _ = em_env.set_env_var(name.as_ref(), prev.as_ref());
     }
@@ -84,7 +82,9 @@ pub fn _unsetenv(mut ctx: FunctionEnvMut<EmEnv>, name: c_int) -> c_int {
         let em_env = ctx.data();
         let memory = em_env.memory(0);
         let name_addr = emscripten_memory_pointer!(memory.view(&ctx), name) as *const c_char;
-        unsafe { CStr::from_ptr(name_addr) }.to_string_lossy().to_string()
+        unsafe { CStr::from_ptr(name_addr) }
+            .to_string_lossy()
+            .to_string()
     };
 
     debug!("=> name({:?})", name);

lib/emscripten/src/lib.rs

@@ -87,9 +87,8 @@ impl Default for EmscriptenState {
     fn default() -> Self {
         Self {
             env_vars: std::env::vars_os()
-            .filter_map(|(k, v)| {
+                .filter_map(|(k, v)| Some((k.to_str()?.to_string(), v.to_str()?.to_string())))
-                Some((k.to_str()?.to_string(), v.to_str()?.to_string()))
+                .collect(),
-            }).collect(),
             cli_args: Vec::new(),
         }
     }
@@ -155,10 +154,7 @@ impl EmEnv {
         *w = Some(EmscriptenData::new(data.clone(), mapped_dirs));
     }
 
-    pub fn get_env_var(
+    pub fn get_env_var(&self, key: &str) -> Option<String> {
-        &self,
-        key: &str,
-    ) -> Option<String> {
         let w = self.state.lock().ok()?;
         let result = w.env_vars.get(key).cloned();
         result
@@ -169,19 +165,12 @@ impl EmEnv {
         w.env_vars.len()
     }
 
-    pub fn set_env_var(
+    pub fn set_env_var(&self, key: &str, value: &str) -> Option<String> {
-        &self,
-        key: &str,
-        value: &str,
-    ) -> Option<String> {
         let mut w = self.state.lock().ok()?;
         w.env_vars.insert(key.to_string(), value.to_string())
     }
 
-    pub fn remove_env_var(
+    pub fn remove_env_var(&self, key: &str) -> Option<String> {
-        &self,
-        key: &str,
-    ) -> Option<String> {
         let mut w = self.state.lock().ok()?;
         w.env_vars.remove(key)
     }

lib/registry/src/lib.rs

@@ -477,7 +477,6 @@ pub fn get_all_local_packages() -> Vec<LocalPackage> {
     let mut packages = Vec::new();
 
     'outer: for registry in get_all_available_registries().unwrap_or_default() {
-
         let host = match url::Url::parse(&registry) {
             Ok(o) => o.host_str().map(|s| s.to_string()),
             Err(_) => continue 'outer,
@@ -487,7 +486,7 @@ pub fn get_all_local_packages() -> Vec<LocalPackage> {
             Some(s) => s,
             None => continue 'outer,
         };
-        
+
         let root_dir = match get_global_install_dir(&host) {
             Some(o) => o,
             None => continue 'outer,
@@ -558,7 +557,7 @@ pub fn get_package_local_wasm_file(
         .ok_or(format!(
             "cannot get entrypoint for {name}@{version}: package has no commands"
         ))?;
-    
+
     let wasm_file_name = wapm
         .module
         .unwrap_or_default()
@@ -569,7 +568,7 @@ pub fn get_package_local_wasm_file(
         .ok_or(format!(
             "cannot get entrypoint for {name}@{version}: package has no commands"
         ))?;
-    
+
     Ok(dir.join(&wasm_file_name))
 }
 
@@ -588,15 +587,18 @@ pub enum QueryPackageError {
         name: String,
         version: Option<String>,
         packages: Vec<PackageDownloadInfo>,
-    }
+    },
 }
 
 impl QueryPackageError {
     pub fn get_packages(&self) -> Vec<PackageDownloadInfo> {
         match self {
-            QueryPackageError::AmbigouusName { name: _, packages } |
+            QueryPackageError::AmbigouusName { name: _, packages }
-            QueryPackageError::NoPackageFound { name: _, version: _, packages }
+            | QueryPackageError::NoPackageFound {
-            => packages.clone(),
+                name: _,
+                version: _,
+                packages,
+            } => packages.clone(),
             _ => Vec::new(),
         }
     }
@@ -622,8 +624,10 @@ pub fn query_package_from_registry(
         })
     };
 
-    let response: get_packages_query::ResponseData = execute_query(registry_url, "", &q)
+    let response: get_packages_query::ResponseData =
-        .map_err(|e| QueryPackageError::ErrorSendingQuery(format!("Error sending GetPackagesQuery:  {e}")))?;
+        execute_query(registry_url, "", &q).map_err(|e| {
+            QueryPackageError::ErrorSendingQuery(format!("Error sending GetPackagesQuery:  {e}"))
+        })?;
 
     let available_packages = response
         .package
@@ -690,12 +694,12 @@ pub fn query_package_from_registry(
 
     match queried_package {
         None => {
-            return Err(QueryPackageError::NoPackageFound { 
+            return Err(QueryPackageError::NoPackageFound {
-                name: name.to_string(), 
+                name: name.to_string(),
                 version: version.as_ref().map(|s| s.to_string()),
                 packages: available_packages,
             });
-        },
+        }
         Some(s) => Ok(s),
     }
 }
@@ -752,7 +756,10 @@ pub fn download_and_unpack_targz(url: &str, target_path: &Path) -> Result<PathBu
     Ok(target_path.to_path_buf())
 }
 
-pub fn install_package(name: &str, version: Option<&str>) -> Result<(LocalPackage, PathBuf), String> {
+pub fn install_package(
+    name: &str,
+    version: Option<&str>,
+) -> Result<(LocalPackage, PathBuf), String> {
     let registries = get_all_available_registries()?;
     let mut url_of_package = None;
     let mut error_packages = Vec::new();
@@ -784,7 +791,8 @@ pub fn install_package(name: &str, version: Option<&str>) -> Result<(LocalPackag
         .filter_map(|s| Some(format!("{}", s.host_str()?)))
         .collect::<Vec<_>>();
 
-    let mut error_str = format!("Package {version_str} not found in registries {registries_searched:?}.");
+    let mut error_str =
+        format!("Package {version_str} not found in registries {registries_searched:?}.");
     let mut did_you_mean = error_packages
         .iter()
         .flat_map(|error| {
@@ -800,7 +808,7 @@ pub fn install_package(name: &str, version: Option<&str>) -> Result<(LocalPackag
             .into_iter()
         })
         .collect::<Vec<_>>();
-    
+
     let did_you_mean = if did_you_mean.is_empty() {
         String::new()
     } else {
@@ -809,8 +817,7 @@ pub fn install_package(name: &str, version: Option<&str>) -> Result<(LocalPackag
         format!("\r\n\r\nDid you mean:\r\n{}\r\n", did_you_mean.join("\r\n"))
     };
 
-    let (_, package_info) = url_of_package
+    let (_, package_info) = url_of_package.ok_or(format!("{error_str}{did_you_mean}"))?;
-    .ok_or(format!("{error_str}{did_you_mean}"))?;
 
     let host = url::Url::parse(&package_info.registry)
         .map_err(|e| format!("invalid url: {}: {e}", package_info.registry))?
@@ -818,8 +825,7 @@ pub fn install_package(name: &str, version: Option<&str>) -> Result<(LocalPackag
         .ok_or(format!("invalid url: {}", package_info.registry))?
         .to_string();
 
-    let dir = get_package_local_dir(
+    let dir = get_package_local_dir(&host, &package_info.package, &package_info.version)?;
-        &host, &package_info.package, &package_info.version)?;
 
     let version = package_info.version;
     let name = package_info.package;
@@ -854,13 +860,16 @@ pub fn install_package(name: &str, version: Option<&str>) -> Result<(LocalPackag
             "Cannot run {name}@{version}: module {module_name} not found in wapm.toml"
         ))?;
 
-    Ok((LocalPackage {
+    Ok((
-        registry: package_info.registry.clone(),
+        LocalPackage {
-        name: wapm_toml.package.name.clone(),
+            registry: package_info.registry.clone(),
-        version: wapm_toml.package.version.to_string(),
+            name: wapm_toml.package.name.clone(),
-        manifest: wapm_toml,
+            version: wapm_toml.package.version.to_string(),
-        path: target_path.clone(),
+            manifest: wapm_toml,
-    }, target_path.join(&entrypoint_module.source)))
+            path: target_path.clone(),
+        },
+        target_path.join(&entrypoint_module.source),
+    ))
 }
 
 pub fn test_if_registry_present(registry: &str) -> Result<bool, String> {