Use 'url' crate to manage file URLs

Treating them as strings works fine for *nix OSes, but breaks for
Windows.

Also, standardize on "URL" vs "URI" in spin-trigger crate.

Signed-off-by: Lann Martin <lann.martin@fermyon.com>

Author: lann

crates/trigger/src/lib.rs

@@ -9,7 +9,7 @@ use std::{
     path::{Path, PathBuf},
 };
 
-use anyhow::{Context, Result};
+use anyhow::{anyhow, Context, Result};
 pub use async_trait::async_trait;
 use serde::de::DeserializeOwned;
 
@@ -130,9 +130,11 @@ impl<Executor: TriggerExecutor> TriggerExecutorBuilder<Executor> {
 
     pub fn default_config_providers(&self, app_uri: &str) -> Vec<Box<dyn Provider>> {
         // EnvProvider
-        let dotenv_path = app_uri
-            .strip_prefix("file://")
-            .and_then(|path| Path::new(path).parent())
+        // Look for a .env file in either the manifest parent directory for local apps
+        // or the current directory for remote (e.g. bindle) apps.
+        let dotenv_path = parse_file_url(app_uri)
+            .as_deref()
+            .ok()
             .unwrap_or_else(|| Path::new("."))
             .join(".env");
         vec![Box::new(EnvProvider::new(
@@ -280,3 +282,10 @@ impl<Executor: TriggerExecutor> TriggerAppEngine<Executor> {
         Ok((instance, store))
     }
 }
+
+pub(crate) fn parse_file_url(url: &str) -> Result<PathBuf> {
+    url::Url::parse(url)
+        .with_context(|| format!("Invalid URL: {url:?}"))?
+        .to_file_path()
+        .map_err(|_| anyhow!("Invalid file URL path: {url:?}"))
+}

crates/trigger/src/loader.rs

@@ -1,6 +1,6 @@
 #![allow(dead_code)] // Refactor WIP
 
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 
 use anyhow::{ensure, Context, Result};
 use async_trait::async_trait;
@@ -10,6 +10,8 @@ use spin_app::{
 };
 use spin_core::StoreBuilder;
 
+use crate::parse_file_url;
+
 pub struct TriggerLoader {
     working_dir: PathBuf,
     allow_transient_write: bool,
@@ -26,10 +28,10 @@ impl TriggerLoader {
 
 #[async_trait]
 impl Loader for TriggerLoader {
-    async fn load_app(&self, uri: &str) -> Result<LockedApp> {
-        let path = unwrap_file_uri(uri)?;
+    async fn load_app(&self, url: &str) -> Result<LockedApp> {
+        let path = parse_file_url(url)?;
         let contents =
-            std::fs::read(path).with_context(|| format!("failed to read manifest at {path:?}"))?;
+            std::fs::read(&path).with_context(|| format!("failed to read manifest at {path:?}"))?;
         let app =
             serde_json::from_slice(&contents).context("failed to parse app lock file JSON")?;
         Ok(app)
@@ -45,8 +47,8 @@ impl Loader for TriggerLoader {
             .source
             .as_ref()
             .context("LockedComponentSource missing source field")?;
-        let path = unwrap_file_uri(source)?;
-        spin_core::Module::from_file(engine, path)
+        let path = parse_file_url(source)?;
+        spin_core::Module::from_file(engine, &path)
             .with_context(|| format!("loading module {path:?}"))
     }
 
@@ -61,7 +63,7 @@ impl Loader for TriggerLoader {
                 .source
                 .as_deref()
                 .with_context(|| format!("Missing 'source' on files mount {content_dir:?}"))?;
-            let source_path = self.working_dir.join(unwrap_file_uri(source_uri)?);
+            let source_path = self.working_dir.join(parse_file_url(source_uri)?);
             ensure!(
                 source_path.is_dir(),
                 "TriggerLoader only supports directory mounts; {source_path:?} is not a directory"
@@ -76,10 +78,3 @@ impl Loader for TriggerLoader {
         Ok(())
     }
 }
-
-fn unwrap_file_uri(uri: &str) -> Result<&Path> {
-    Ok(Path::new(
-        uri.strip_prefix("file://")
-            .context("TriggerLoader supports only file:// URIs")?,
-    ))
-}

crates/trigger/src/locked.rs

@@ -47,7 +47,7 @@ impl LockedAppBuilder {
             .string("version", &info.version)
             .string_option("description", info.description.as_deref())
             .serializable("trigger", info.trigger)?;
-        // Convert ApplicationOrigin to a URI
+        // Convert ApplicationOrigin to a URL
         builder.string(
             "origin",
             match info.origin {
@@ -185,13 +185,13 @@ fn content_ref_path(path: &Path) -> Result<ContentRef> {
 
 fn file_uri(path: &Path) -> Result<String> {
     let path = path.canonicalize()?;
-    let uri = if path.is_dir() {
+    let url = if path.is_dir() {
         url::Url::from_directory_path(&path)
     } else {
         url::Url::from_file_path(&path)
     }
-    .map_err(|_| anyhow!("Could not construct file URI for {path:?}"))?;
-    Ok(uri.to_string())
+    .map_err(|_| anyhow!("Could not construct file URL for {path:?}"))?;
+    Ok(url.to_string())
 }
 
 #[cfg(test)]

src/commands/up.rs

@@ -4,8 +4,9 @@ use std::{
     path::{Path, PathBuf},
 };
 
-use anyhow::{bail, Context, Result};
+use anyhow::{anyhow, bail, Context, Result};
 use clap::{CommandFactory, Parser};
+use reqwest::Url;
 use spin_loader::bindle::BindleConnectionInfo;
 use spin_manifest::ApplicationTrigger;
 use spin_trigger::cli::{SPIN_LOCKED_URL, SPIN_WORKING_DIR};
@@ -154,7 +155,9 @@ impl UpCommand {
             serde_json::to_vec_pretty(&locked_app).context("failed to serialize locked app")?;
         std::fs::write(&locked_path, locked_app_contents)
             .with_context(|| format!("failed to write {:?}", locked_path))?;
-        let locked_url = format!("file://{}", locked_path.to_string_lossy());
+        let locked_url = Url::from_file_path(&locked_path)
+            .map_err(|_| anyhow!("cannot convert to file URL: {locked_path:?}"))?
+            .to_string();
 
         // For `spin up --help`, we just want the executor to dump its own argument usage info
         let trigger_args = if self.help {