refactor builder interface

Author: spennydl

examples/docs-builder.rs

@@ -26,7 +26,7 @@ fn main() -> Result<(), Box<dyn Error>> {
         .enable_networking(false);
 
     let mut build_dir = workspace.build_dir("docs");
-    build_dir.build(&toolchain, &krate, sandbox, |build| {
+    build_dir.build(&toolchain, &krate, sandbox).run(|build| {
         build.cargo().args(&["doc", "--no-deps"]).run()?;
         Ok(())
     })?;

src/build.rs

@@ -18,64 +18,21 @@ pub struct BuildDirectory {
 
 pub struct Builder<'a> {
     build_dir: &'a mut BuildDirectory,
-    toolchain: Option<&'a Toolchain>,
-    krate: Option<Crate>,
-    sandbox: Option<SandboxBuilder>,
+    toolchain: &'a Toolchain,
+    krate: &'a Crate,
+    sandbox: SandboxBuilder,
     patches: Vec<CratePatch>,
 }
 
 impl<'a> Builder<'a> {
-    pub(crate) fn new(build_dir: &'a mut BuildDirectory) -> Self {
-        Builder {
-            build_dir,
-            toolchain: None,
-            krate: None,
-            sandbox: None,
-            patches: Vec::new()
-        }
-    }
-
-    pub fn toolchain(mut self, toolchain: &'a Toolchain) -> Self {
-        self.toolchain.replace(toolchain);
-        self
-    }
-
-    pub fn krate(mut self, krate: Crate) -> Self {
-        self.krate.replace(krate);
-        self
-    }
-
-    pub fn sandbox(mut self, sandbox: SandboxBuilder) -> Self {
-        self.sandbox.replace(sandbox);
-        self
-    }
 
     pub fn patch(mut self, patch: CratePatch) -> Self {
         self.patches.push(patch);
         self
     }
 
-    pub fn build<R, F: FnOnce(&Build) -> Result<R, Error>>(mut self, f: F) -> Result<R, Error> {
-        let tc = match self.toolchain {
-            Some(t) => t,
-            None => return Err(failure::err_msg("No tc")),
-        };
-
-        let kr = match self.krate {
-            Some(mut k) => {
-                self.patches.drain(..).for_each(|p| k.add_patch(p));
-                k
-            },
-            None => return Err(failure::err_msg("no krate")),
-        };
-
-        let sn = match self.sandbox {
-            Some(s) => s,
-            None => return Err(failure::err_msg("No sandbox")),
-        };
-
-
-        self.build_dir.build(tc, &kr, sn, f)
+    pub fn run<R, F: FnOnce(&Build) -> Result<R, Error>>(self, f: F) -> Result<R, Error> {
+        self.build_dir.run(self.toolchain, self.krate, self.sandbox, self.patches, f)
     }
 }
 
@@ -87,8 +44,14 @@ impl BuildDirectory {
         }
     }
 
-    pub fn builder(&mut self) -> Builder {
-        Builder::new(self)
+    pub fn build<'a>(&'a mut self,
+        toolchain: &'a Toolchain,
+        krate: &'a Crate,
+        sandbox: SandboxBuilder,
+    ) -> Builder {
+        Builder {
+            build_dir: self, toolchain, krate, sandbox, patches: Vec::new()
+        }
     }
 
     /// Run a sandboxed build of the provided crate with the provided toolchain. The closure will
@@ -116,19 +79,20 @@ impl BuildDirectory {
     /// # Ok(())
     /// # }
     /// ```
-    pub fn build<R, F: FnOnce(&Build) -> Result<R, Error>>(
+    pub(crate) fn run<R, F: FnOnce(&Build) -> Result<R, Error>>(
         &mut self,
         toolchain: &Toolchain,
         krate: &Crate,
         sandbox: SandboxBuilder,
+        patches: Vec<CratePatch>,
         f: F,
     ) -> Result<R, Error> {
         let source_dir = self.source_dir();
         if source_dir.exists() {
             remove_dir_all(&source_dir)?;
         }
 
-        let mut prepare = Prepare::new(&self.workspace, toolchain, krate, &source_dir);
+        let mut prepare = Prepare::new(&self.workspace, toolchain, krate, &source_dir, patches);
         prepare.prepare()?;
 
         std::fs::create_dir_all(self.target_dir())?;

src/crates/mod.rs

@@ -28,25 +28,25 @@ pub struct CratePatch {
 }
 
 /// A Rust crate that can be used with rustwide.
-pub struct Crate(CrateType, Option<Vec<CratePatch>>);
+pub struct Crate(CrateType);
 
 impl Crate {
     /// Load a crate from the [crates.io registry](https://crates.io).
     pub fn crates_io(name: &str, version: &str) -> Self {
         Crate(CrateType::CratesIO(cratesio::CratesIOCrate::new(
             name, version,
-        )), None)
+        )))
     }
 
     /// Load a crate from a git repository. The full URL needed to clone the repo has to be
     /// provided.
     pub fn git(url: &str) -> Self {
-        Crate(CrateType::Git(git::GitRepo::new(url)), None)
+        Crate(CrateType::Git(git::GitRepo::new(url)))
     }
 
     /// Load a crate from a directory in the local filesystem.
     pub fn local(path: &Path) -> Self {
-        Crate(CrateType::Local(local::Local::new(path)), None)
+        Crate(CrateType::Local(local::Local::new(path)))
     }
 
     /// Fetch the crate's source code and cache it in the workspace. This method will reach out to
@@ -70,15 +70,6 @@ impl Crate {
         }
     }
 
-    pub(crate) fn add_patch(&mut self, patch: CratePatch) {
-        let patches: &mut Vec<CratePatch> = self.1.get_or_insert(Vec::new());
-        patches.push(patch);
-    }
-
-    pub(crate) fn patches(&self) -> &Option<Vec<CratePatch>> {
-        &self.1
-    }
-
     pub(crate) fn copy_source_to(&self, workspace: &Workspace, dest: &Path) -> Result<(), Error> {
         if dest.exists() {
             info!(

src/prepare.rs

@@ -1,5 +1,5 @@
 use crate::cmd::Command;
-use crate::{Crate, Toolchain, Workspace};
+use crate::{Crate, crates::CratePatch, Toolchain, Workspace};
 use failure::{Error, Fail, ResultExt};
 use log::info;
 use std::path::Path;
@@ -14,6 +14,7 @@ pub(crate) struct Prepare<'a> {
     krate: &'a Crate,
     source_dir: &'a Path,
     lockfile_captured: bool,
+    patches: Vec<CratePatch>
 }
 
 impl<'a> Prepare<'a> {
@@ -22,13 +23,15 @@ impl<'a> Prepare<'a> {
         toolchain: &'a Toolchain,
         krate: &'a Crate,
         source_dir: &'a Path,
+        patches: Vec<CratePatch>
     ) -> Self {
         Self {
             workspace,
             toolchain,
             krate,
             source_dir,
             lockfile_captured: false,
+            patches,
         }
     }
 
@@ -67,7 +70,7 @@ impl<'a> Prepare<'a> {
 
     fn tweak_toml(&self) -> Result<(), Error> {
         let path = self.source_dir.join("Cargo.toml");
-        let mut tweaker = TomlTweaker::new(&self.krate, &path)?;
+        let mut tweaker = TomlTweaker::new(&self.krate, &path, &self.patches)?;
         tweaker.tweak();
         tweaker.save(&path)?;
         Ok(())
@@ -143,26 +146,28 @@ pub struct TomlTweaker<'a> {
     krate: &'a Crate,
     table: Table,
     dir: Option<&'a Path>,
+    patches: &'a Vec<CratePatch>,
 }
 
 impl<'a> TomlTweaker<'a> {
-    pub fn new(krate: &'a Crate, cargo_toml: &'a Path) -> Result<Self, Error> {
+    pub fn new(krate: &'a Crate, cargo_toml: &'a Path, patches: &'a Vec<CratePatch>) -> Result<Self, Error> {
         let toml_content = ::std::fs::read_to_string(cargo_toml)
             .with_context(|_| PrepareError::MissingCargoToml)?;
         let table: Table =
             toml::from_str(&toml_content).with_context(|_| PrepareError::InvalidCargoTomlSyntax)?;
 
         let dir = cargo_toml.parent();
 
-        Ok(TomlTweaker { krate, table, dir })
+        Ok(TomlTweaker { krate, table, dir, patches })
     }
 
     #[cfg(test)]
-    fn new_with_table(krate: &'a Crate, table: Table) -> Self {
+    fn new_with_table(krate: &'a Crate, table: Table, patches: &'a Vec<CratePatch>) -> Self {
         TomlTweaker {
             krate,
             table,
             dir: None,
+            patches,
         }
     }
 
@@ -277,13 +282,13 @@ impl<'a> TomlTweaker<'a> {
     }
 
     fn apply_patches(&mut self) {
-        if let Some(krate_patches) = self.krate.patches() {
+        if self.patches.len() > 0 {
             if !self.table.contains_key("patch.crates-io") {
                 self.table.insert("patch.crates-io".into(), Value::Table(Table::new()));
             }
 
             if let Some(&mut Value::Table(ref mut patches)) = self.table.get_mut("patch.crates-io") {
-                for patch in krate_patches.iter().cloned() {
+                for patch in self.patches.iter().cloned() {
                     let mut patch_table = Table::new();
                     patch_table.insert("git".into(), Value::String(patch.uri));
                     patch_table.insert("branch".into(), Value::String(patch.branch));