Merge pull request #56 from regexident/path-patch

Add support for path-based patches

Author: pietroalbini

CHANGELOG.md

@@ -5,6 +5,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+### Added
+
+- New method `BuildBuilder::patch_with_path()` for path-based patching (as compared to git-based).
+
 ## [0.14.0] - 2021-08-19
 
 ### Added

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();

tests/buildtest/crates/path-based-patch/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "path-based-patch"
+version = "0.1.0"
+authors = ["Pietro Albini <[email protected]>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+empty-library = "1.0.0"

tests/buildtest/crates/path-based-patch/patch/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "empty-library"
+version = "1.0.1"
+authors = ["Pietro Albini <[email protected]>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

tests/buildtest/crates/path-based-patch/patch/src/lib.rs

@@ -0,0 +1,3 @@
+pub fn dummy() {
+    println!("This is coming from the patch!");
+}

tests/buildtest/crates/path-based-patch/src/main.rs

@@ -0,0 +1,4 @@
+fn main() {
+    println!("Hello, world!");
+    empty_library::dummy();
+}

tests/buildtest/inside_docker.rs

@@ -15,6 +15,12 @@ fn test_hello_world() {
     execute("buildtest::test_hello_world").unwrap();
 }
 
+#[test]
+#[cfg(unix)]
+fn test_path_based_patch() {
+    execute("buildtest::path_based_patch").unwrap();
+}
+
 fn execute(test: &str) -> Result<(), Error> {
     // The current working directory is mounted in the container to /outside.
     // The binary to execute is remapped to be prefixed by /outside instead of the current

tests/buildtest/mod.rs

@@ -9,7 +9,7 @@ mod inside_docker;
 #[test]
 fn test_hello_world() {
     runner::run("hello-world", |run| {
-        run.build(SandboxBuilder::new().enable_networking(false), |build| {
+        run.run(SandboxBuilder::new().enable_networking(false), |build| {
             let storage = rustwide::logging::LogStorage::new(LevelFilter::Info);
             rustwide::logging::capture(&storage, || -> Result<_, Error> {
                 build.cargo().args(&["run"]).run()?;
@@ -26,10 +26,34 @@ fn test_hello_world() {
     });
 }
 
+#[test]
+fn path_based_patch() {
+    runner::run("path-based-patch", |run| {
+        run.build(SandboxBuilder::new().enable_networking(false), |builder| {
+            builder
+                .patch_with_path("empty-library", "./patch")
+                .run(move |build| {
+                    let storage = rustwide::logging::LogStorage::new(LevelFilter::Info);
+                    rustwide::logging::capture(&storage, || -> Result<_, Error> {
+                        build.cargo().args(&["run"]).run()?;
+                        Ok(())
+                    })?;
+
+                    assert!(storage.to_string().contains("[stdout] Hello, world!\n"));
+                    assert!(storage
+                        .to_string()
+                        .contains("[stdout] This is coming from the patch!\n"));
+                    Ok(())
+                })
+        })?;
+        Ok(())
+    });
+}
+
 #[test]
 fn test_process_lines() {
     runner::run("process-lines", |run| {
-        run.build(SandboxBuilder::new().enable_networking(false), |build| {
+        run.run(SandboxBuilder::new().enable_networking(false), |build| {
             let storage = rustwide::logging::LogStorage::new(LevelFilter::Info);
             let mut ex = false;
             rustwide::logging::capture(&storage, || -> Result<_, Error> {
@@ -64,7 +88,7 @@ fn test_sandbox_oom() {
     use rustwide::cmd::CommandError;
 
     runner::run("out-of-memory", |run| {
-        let res = run.build(
+        let res = run.run(
             SandboxBuilder::new()
                 .enable_networking(false)
                 .memory_limit(Some(512 * 1024 * 1024)),
@@ -85,7 +109,7 @@ fn test_sandbox_oom() {
 #[test]
 fn test_override_files() {
     runner::run("cargo-config", |run| {
-        run.build(SandboxBuilder::new().enable_networking(false), |build| {
+        run.run(SandboxBuilder::new().enable_networking(false), |build| {
             let storage = rustwide::logging::LogStorage::new(LevelFilter::Info);
             rustwide::logging::capture(&storage, || -> Result<_, Error> {
                 build.cargo().args(&["--version"]).run()?;
@@ -104,7 +128,7 @@ fn test_override_files() {
 #[test]
 fn test_cargo_workspace() {
     runner::run("cargo-workspace", |run| {
-        run.build(SandboxBuilder::new().enable_networking(false), |build| {
+        run.run(SandboxBuilder::new().enable_networking(false), |build| {
             let storage = rustwide::logging::LogStorage::new(LevelFilter::Info);
             rustwide::logging::capture(&storage, || -> Result<_, Error> {
                 build.cargo().args(&["run"]).run()?;

tests/buildtest/runner.rs

@@ -1,5 +1,5 @@
 use failure::Error;
-use rustwide::{cmd::SandboxBuilder, Build, Crate, Toolchain, Workspace};
+use rustwide::{cmd::SandboxBuilder, Build, BuildBuilder, Crate, Toolchain, Workspace};
 use std::path::Path;
 
 pub(crate) fn run(crate_name: &str, f: impl FnOnce(&mut Runner) -> Result<(), Error>) {
@@ -38,11 +38,19 @@ impl Runner {
     pub(crate) fn build<T>(
         &self,
         sandbox: SandboxBuilder,
-        f: impl FnOnce(&Build) -> Result<T, Error>,
+        f: impl FnOnce(BuildBuilder) -> Result<T, Error>,
     ) -> Result<T, Error> {
         let mut dir = self.workspace.build_dir(&self.crate_name);
         dir.purge()?;
-        dir.build(&self.toolchain, &self.krate, sandbox).run(f)
+        f(dir.build(&self.toolchain, &self.krate, sandbox))
+    }
+
+    pub(crate) fn run<T>(
+        &self,
+        sandbox: SandboxBuilder,
+        f: impl FnOnce(&Build) -> Result<T, Error>,
+    ) -> Result<T, Error> {
+        self.build(sandbox, |builder| builder.run(f))
     }
 }
 
@@ -51,7 +59,7 @@ macro_rules! test_prepare_error {
         #[test]
         fn $name() {
             runner::run($krate, |run| {
-                let res = run.build(
+                let res = run.run(
                     rustwide::cmd::SandboxBuilder::new().enable_networking(false),
                     |_| Ok(()),
                 );