Add support for path-based patches

Author: regexident

src/build.rs

@@ -6,12 +6,24 @@ use std::path::PathBuf;
 use std::vec::Vec;
 
 #[derive(Clone)]
-pub(crate) struct CratePatch {
+pub(crate) enum CratePatch {
+    Git(GitCratePatch),
+    Path(PathCratePatch),
+}
+
+#[derive(Clone)]
+pub(crate) struct GitCratePatch {
     pub(crate) name: String,
     pub(crate) uri: String,
     pub(crate) branch: String,
 }
 
+#[derive(Clone)]
+pub(crate) struct PathCratePatch {
+    pub(crate) name: String,
+    pub(crate) path: String,
+}
+
 /// Directory in the [`Workspace`](struct.Workspace.html) where builds can be executed.
 ///
 /// The build directory contains the source code of the crate being built and the target directory
@@ -32,7 +44,7 @@ pub struct BuildBuilder<'a> {
 }
 
 impl<'a> BuildBuilder<'a> {
-    /// Add a patch to this build.
+    /// Add a git-based patch to this build.
     /// Patches get added to the crate's Cargo.toml in the `patch.crates-io` table.
     /// # Example
     ///
@@ -54,11 +66,45 @@ impl<'a> BuildBuilder<'a> {
     /// # Ok(())
     /// # }
     pub fn patch_with_git(mut self, name: &str, uri: &str, branch: &str) -> Self {
-        self.patches.push(CratePatch {
+        self.patches.push(CratePatch::Git(GitCratePatch {
             name: name.into(),
             uri: uri.into(),
             branch: branch.into(),
-        });
+        }));
+        self
+    }
+
+    /// Add a path-based patch to this build.
+    /// Patches get added to the crate's Cargo.toml in the `patch.crates-io` table.
+    /// # Example
+    ///
+    /// ```no_run
+    /// # use rustwide::{WorkspaceBuilder, Toolchain, Crate, cmd::{MountKind, SandboxBuilder}};
+    /// # use std::{error::Error, path::{Path, PathBuf}};
+    /// # fn main() -> Result<(), Box<dyn Error>> {
+    /// # let workspace = WorkspaceBuilder::new("".as_ref(), "").init()?;
+    /// # let toolchain = Toolchain::dist("");
+    /// # let krate = Crate::local("".as_ref());
+    /// # let manifest_dir = "/path/to/bar";
+    /// let sandbox = SandboxBuilder::new().mount(
+    ///     Path::new(manifest_dir),
+    ///     Path::new("/patch/bar"),
+    ///     MountKind::ReadOnly,
+    /// );
+    /// let mut build_dir = workspace.build_dir("foo");
+    /// build_dir.build(&toolchain, &krate, sandbox)
+    ///     .patch_with_path("bar", "/patch/bar")
+    ///     .run(|build| {
+    ///         build.cargo().args(&["test", "--all"]).run()?;
+    ///         Ok(())
+    ///     })?;
+    /// # Ok(())
+    /// # }
+    pub fn patch_with_path(mut self, name: &str, path: &str) -> Self {
+        self.patches.push(CratePatch::Path(PathCratePatch {
+            name: name.into(),
+            path: path.into(),
+        }));
         self
     }
 

src/prepare.rs

@@ -312,13 +312,24 @@ impl<'a> TomlTweaker<'a> {
             };
 
             for patch in self.patches.iter().cloned() {
-                let mut table = Table::new();
-                table.insert("git".into(), Value::String(patch.uri));
-                table.insert("branch".into(), Value::String(patch.branch));
+                let (name, table) = match patch {
+                    CratePatch::Git(patch) => {
+                        let mut table = Table::new();
+                        table.insert("git".into(), Value::String(patch.uri));
+                        table.insert("branch".into(), Value::String(patch.branch));
+                        (patch.name, table)
+                    }
+                    CratePatch::Path(patch) => {
+                        let mut table = Table::new();
+                        table.insert("path".into(), Value::String(patch.path.clone()));
+                        (patch.name, table)
+                    }
+                };
+
                 cratesio_table
                     .as_table_mut()
                     .unwrap()
-                    .insert(patch.name, Value::Table(table));
+                    .insert(name, Value::Table(table));
             }
         }
     }
@@ -361,7 +372,7 @@ pub enum PrepareError {
 #[cfg(test)]
 mod tests {
     use super::TomlTweaker;
-    use crate::build::CratePatch;
+    use crate::build::{CratePatch, GitCratePatch, PathCratePatch};
     use crate::crates::Crate;
     use toml::{self, Value};
 
@@ -459,14 +470,21 @@ mod tests {
 
             [patch.crates-io]
             quux = { git = "https://git.example.com/quux", branch = "dev" }
+            baz = { path = "/path/to/baz" }
         };
 
         let krate = Crate::local("/dev/null".as_ref());
-        let patches = vec![CratePatch {
-            name: "quux".into(),
-            uri: "https://git.example.com/quux".into(),
-            branch: "dev".into(),
-        }];
+        let patches = vec![
+            CratePatch::Git(GitCratePatch {
+                name: "quux".into(),
+                uri: "https://git.example.com/quux".into(),
+                branch: "dev".into(),
+            }),
+            CratePatch::Path(PathCratePatch {
+                name: "baz".into(),
+                path: "/path/to/baz".into(),
+            }),
+        ];
         let mut tweaker =
             TomlTweaker::new_with_table(&krate, toml.as_table().unwrap().clone(), &patches);
         tweaker.tweak();