Run `cargo fmt`

Signed-off-by: Matthias Beyer <matthias.beyer@atos.net>

5 files changed, 169 insertions, 70 deletions

diff --git a/src/job/job.rs b/src/job/job.rs
index d5ec7b6..80a05f3 100644
--- a/src/job/job.rs
+++ b/src/job/job.rs
@@ -13,8 +13,8 @@ use uuid::Uuid;
 
 use crate::job::JobResource;
 use crate::package::Package;
-use crate::package::Shebang;
 use crate::package::PhaseName;
+use crate::package::Shebang;
 use crate::util::docker::ImageName;
 
 /// A prepared, but not necessarily runnable, job configuration
@@ -22,27 +22,32 @@ use crate::util::docker::ImageName;
 pub struct Job {
     /// A unique name for the job, not necessarily human-readable
     #[getset(get = "pub")]
-    pub(in super) uuid: Uuid,
+    pub(super) uuid: Uuid,
 
     #[getset(get = "pub")]
-    pub(in super) package: Package,
+    pub(super) package: Package,
 
     #[getset(get = "pub")]
-    pub(in super) image: ImageName,
+    pub(super) image: ImageName,
 
     #[getset(get = "pub")]
-    pub(in super) script_shebang: Shebang,
+    pub(super) script_shebang: Shebang,
 
     #[getset(get = "pub")]
-    pub(in super) script_phases: Vec<PhaseName>,
+    pub(super) script_phases: Vec<PhaseName>,
 
     #[getset(get = "pub")]
-    pub(in super) resources: Vec<JobResource>,
+    pub(super) resources: Vec<JobResource>,
 }
 
 impl Job {
-
-    pub fn new(pkg: Package, script_shebang: Shebang, image: ImageName, phases: Vec<PhaseName>, resources: Vec<JobResource>) -> Self {
+    pub fn new(
+        pkg: Package,
+        script_shebang: Shebang,
+        image: ImageName,
+        phases: Vec<PhaseName>,
+        resources: Vec<JobResource>,
+    ) -> Self {
         let uuid = Uuid::new_v4();
 
         Job {
@@ -53,8 +58,5 @@ impl Job {
             script_phases: phases,
             resources,
         }
-
     }
-
 }
-
diff --git a/src/job/mod.rs b/src/job/mod.rs
index d0e8bf0..719d2da 100644
--- a/src/job/mod.rs
+++ b/src/job/mod.rs
@@ -20,4 +20,3 @@ pub use resource::*;
 
 mod runnable;
 pub use runnable::*;
-
diff --git a/src/job/resource.rs b/src/job/resource.rs
index 96fd4ae..feff692 100644
--- a/src/job/resource.rs
+++ b/src/job/resource.rs
@@ -14,7 +14,7 @@ use crate::util::EnvironmentVariableName;
 #[derive(Clone, Debug)]
 pub enum JobResource {
     Environment(EnvironmentVariableName, String),
-    Artifact(Artifact)
+    Artifact(Artifact),
 }
 
 impl From<(EnvironmentVariableName, String)> for JobResource {
@@ -27,14 +27,13 @@ impl JobResource {
     pub fn env(&self) -> Option<(&EnvironmentVariableName, &String)> {
         match self {
             JobResource::Environment(k, v) => Some((k, v)),
-            _ => None
+            _ => None,
         }
     }
     pub fn artifact(&self) -> Option<&Artifact> {
         match self {
             JobResource::Artifact(a) => Some(a),
-            _ => None
+            _ => None,
         }
     }
 }
-
diff --git a/src/job/runnable.rs b/src/job/runnable.rs
index fc51ecd..b1b7e82 100644
--- a/src/job/runnable.rs
+++ b/src/job/runnable.rs
@@ -10,12 +10,12 @@
 
 use std::collections::HashMap;
 
+use anyhow::anyhow;
 use anyhow::Context;
 use anyhow::Error;
 use anyhow::Result;
-use anyhow::anyhow;
 use getset::Getters;
-use log::{debug, warn, trace};
+use log::{debug, trace, warn};
 use tokio::stream::StreamExt;
 use uuid::Uuid;
 
@@ -29,8 +29,8 @@ use crate::package::Script;
 use crate::package::ScriptBuilder;
 use crate::source::SourceCache;
 use crate::source::SourceEntry;
-use crate::util::EnvironmentVariableName;
 use crate::util::docker::ImageName;
+use crate::util::EnvironmentVariableName;
 
 /// A job configuration that can be run. All inputs are clear here.
 #[derive(Debug, Getters)]
@@ -39,23 +39,28 @@ pub struct RunnableJob {
     uuid: Uuid,
 
     #[getset(get = "pub")]
-    package:  Package,
+    package: Package,
 
     #[getset(get = "pub")]
-    image:    ImageName,
+    image: ImageName,
 
     #[getset(get = "pub")]
     source_cache: SourceCache,
 
     #[getset(get = "pub")]
-    script:   Script,
+    script: Script,
 
     #[getset(get = "pub")]
     resources: Vec<JobResource>,
 }
 
 impl RunnableJob {
-    pub async fn build_from_job(job: Job, merged_stores: &MergedStores, source_cache: &SourceCache, config: &Configuration) -> Result<Self> {
+    pub async fn build_from_job(
+        job: Job,
+        merged_stores: &MergedStores,
+        source_cache: &SourceCache,
+        config: &Configuration,
+    ) -> Result<Self> {
         trace!("Preparing build dependencies");
         let resources = {
             let mut resources = job
@@ -97,14 +102,23 @@ impl RunnableJob {
                         Ok(())
                     }
                 })
-                .with_context(|| anyhow!("Checking allowed variables for package {} {}", job.package().name(), job.package().version()))
+                .with_context(|| {
+                    anyhow!(
+                        "Checking allowed variables for package {} {}",
+                        job.package().name(),
+                        job.package().version()
+                    )
+                })
                 .context("Checking allowed variable names")?;
         } else {
             debug!("Environment checking disabled");
         }
 
-        let script = ScriptBuilder::new(&job.script_shebang)
-            .build(&job.package, &job.script_phases, *config.strict_script_interpolation())?;
+        let script = ScriptBuilder::new(&job.script_shebang).build(
+            &job.package,
+            &job.script_phases,
+            *config.strict_script_interpolation(),
+        )?;
 
         Ok(RunnableJob {
             uuid: job.uuid,
@@ -115,7 +129,6 @@ impl RunnableJob {
 
             script,
         })
-
     }
 
     pub fn package_sources(&self) -> Vec<SourceEntry> {
@@ -128,18 +141,18 @@ impl RunnableJob {
 
     /// Helper function to collect a list of resources and the result of package.environment() into
     /// a Vec of environment variables
-    fn env_resources(resources: &[JobResource], pkgenv: Option<&HashMap<EnvironmentVariableName, String>>)
-        -> Vec<(EnvironmentVariableName, String)>
-    {
+    fn env_resources(
+        resources: &[JobResource],
+        pkgenv: Option<&HashMap<EnvironmentVariableName, String>>,
+    ) -> Vec<(EnvironmentVariableName, String)> {
         let iter = resources
             .iter()
             .filter_map(JobResource::env)
             .map(|(k, v)| (k.clone(), v.clone()));
 
         if let Some(hm) = pkgenv {
-            iter.chain({
-                hm.iter().map(|(k, v)| (k.clone(), v.clone()))
-            }).collect()
+            iter.chain({ hm.iter().map(|(k, v)| (k.clone(), v.clone())) })
+                .collect()
         } else {
             iter.collect()
         }
@@ -149,25 +162,32 @@ impl RunnableJob {
         vec![
             (
                 String::from("BUTIDO_PACKAGE_NAME"),
-                 self.package().name().clone().to_string()
+                self.package().name().clone().to_string(),
             ),
-
             (
                 String::from("BUTIDO_PACKAGE_VERSION"),
-                self.package().version().clone().to_string()
+                self.package().version().clone().to_string(),
             ),
-
             (
                 String::from("BUTIDO_PACKAGE_VERSION_IS_SEMVER"),
-                String::from(if *self.package().version_is_semver() { "true" } else { "false" })
+                String::from(if *self.package().version_is_semver() {
+                    "true"
+                } else {
+                    "false"
+                }),
             ),
         ]
     }
 
-    async fn build_resource(dep: &dyn ParseDependency, merged_stores: &MergedStores) -> Result<JobResource> {
+    async fn build_resource(
+        dep: &dyn ParseDependency,
+        merged_stores: &MergedStores,
+    ) -> Result<JobResource> {
         let (name, vers) = dep.parse_as_name_and_version()?;
         trace!("Copying dep: {:?} {:?}", name, vers);
-        let mut a = merged_stores.get_artifact_by_name_and_version(&name, &vers).await?;
+        let mut a = merged_stores
+            .get_artifact_by_name_and_version(&name, &vers)
+            .await?;
 
         if a.is_empty() {
             Err(anyhow!("Cannot find dependency: {:?} {:?}", name, vers))
@@ -185,6 +205,5 @@ impl RunnableJob {
 
             Ok(JobResource::Artifact(found_dependency))
         }
-
     }
 }
diff --git a/src/job/set.rs b/src/job/set.rs
index c6f6592..b9e3881 100644
--- a/src/job/set.rs
+++ b/src/job/set.rs
@@ -17,20 +17,26 @@ use crate::filestore::MergedStores;
 use crate::job::Job;
 use crate::job::JobResource;
 use crate::job::RunnableJob;
+use crate::package::PhaseName;
 use crate::package::Shebang;
 use crate::package::Tree;
-use crate::package::PhaseName;
 use crate::source::SourceCache;
 use crate::util::docker::ImageName;
 
 /// A set of jobs that could theoretically be run in parallel
 #[derive(Debug)]
 pub struct JobSet {
-    set: Vec<Job>
+    set: Vec<Job>,
 }
 
 impl JobSet {
-    pub fn sets_from_tree(t: Tree, shebang: Shebang, image: ImageName, phases: Vec<PhaseName>, resources: Vec<JobResource>) -> Result<Vec<JobSet>> {
+    pub fn sets_from_tree(
+        t: Tree,
+        shebang: Shebang,
+        image: ImageName,
+        phases: Vec<PhaseName>,
+        resources: Vec<JobResource>,
+    ) -> Result<Vec<JobSet>> {
         tree_into_jobsets(t, shebang, image, phases, resources)
     }
 
@@ -38,7 +44,12 @@ impl JobSet {
         self.set.is_empty()
     }
 
-    pub async fn into_runables<'a>(self, merged_stores: &'a MergedStores, source_cache: &'a SourceCache, config: &Configuration) -> Result<Vec<RunnableJob>> {
+    pub async fn into_runables<'a>(
+        self,
+        merged_stores: &'a MergedStores,
+        source_cache: &'a SourceCache,
+        config: &Configuration,
+    ) -> Result<Vec<RunnableJob>> {
         self.set
             .into_iter()
             .map(move |j| RunnableJob::build_from_job(j, merged_stores, source_cache, config))
@@ -46,12 +57,23 @@ impl JobSet {
             .collect::<Result<Vec<RunnableJob>>>()
             .await
     }
-
 }
 
 /// Get the tree as sets of jobs, the deepest level of the tree first
-fn tree_into_jobsets(tree: Tree, shebang: Shebang, image: ImageName, phases: Vec<PhaseName>, resources: Vec<JobResource>) -> Result<Vec<JobSet>> {
-    fn inner(tree: Tree, shebang: &Shebang, image: &ImageName, phases: &[PhaseName], resources: &[JobResource]) -> Result<Vec<JobSet>> {
+fn tree_into_jobsets(
+    tree: Tree,
+    shebang: Shebang,
+    image: ImageName,
+    phases: Vec<PhaseName>,
+    resources: Vec<JobResource>,
+) -> Result<Vec<JobSet>> {
+    fn inner(
+        tree: Tree,
+        shebang: &Shebang,
+        image: &ImageName,
+        phases: &[PhaseName],
+        resources: &[JobResource],
+    ) -> Result<Vec<JobSet>> {
         trace!("Creating jobsets for tree: {:?}", tree);
 
         let mut sets = vec![];
@@ -69,7 +91,13 @@ fn tree_into_jobsets(tree: Tree, shebang: Shebang, image: ImageName, phases: Vec
             set: current_set
                 .into_iter()
                 .map(|package| {
-                    Job::new(package, shebang.clone(), image.clone(), phases.to_vec(), resources.to_vec())
+                    Job::new(
+                        package,
+                        shebang.clone(),
+                        image.clone(),
+                        phases.to_vec(),
+                        resources.to_vec(),
+                    )
                 })
                 .collect(),
         };
@@ -103,14 +131,14 @@ mod tests {
 
     use std::collections::BTreeMap;
 
+    use crate::package::tests::package;
     use crate::package::tests::pname;
     use crate::package::tests::pversion;
-    use crate::package::tests::package;
-    use crate::package::Dependency;
     use crate::package::Dependencies;
+    use crate::package::Dependency;
     use crate::package::PhaseName;
-    use crate::util::docker::ImageName;
     use crate::repository::Repository;
+    use crate::util::docker::ImageName;
 
     use indicatif::ProgressBar;
 
@@ -138,7 +166,7 @@ mod tests {
         let r = tree.add_package(p1, &repo, progress);
         assert!(r.is_ok());
 
-        let image  = ImageName::from(String::from("test"));
+        let image = ImageName::from(String::from("test"));
         let phases = vec![PhaseName::from(String::from("testphase"))];
         let shebang = Shebang::from(String::from("#!/bin/bash"));
 
@@ -149,10 +177,20 @@ mod tests {
         assert_eq!(js.len(), 1, "There should be only one jobset if there is only one element in the dependency tree: {:?}", js);
 
         let js = js.get(0).unwrap();
-        assert_eq!(js.set.len(), 1, "The jobset should contain exactly one job: {:?}", js);
+        assert_eq!(
+            js.set.len(),
+            1,
+            "The jobset should contain exactly one job: {:?}",
+            js
+        );
 
         let job = js.set.get(0).unwrap();
-        assert_eq!(*job.package.name(), pname("a"), "The job should be for the package 'a': {:?}", job);
+        assert_eq!(
+            *job.package.name(),
+            pname("a"),
+            "The job should be for the package 'a': {:?}",
+            job
+        );
     }
 
     #[test]
@@ -186,7 +224,7 @@ mod tests {
         let r = tree.add_package(p2, &repo, progress);
         assert!(r.is_ok());
 
-        let image  = ImageName::from(String::from("test"));
+        let image = ImageName::from(String::from("test"));
         let phases = vec![PhaseName::from(String::from("testphase"))];
         let shebang = Shebang::from(String::from("#!/bin/bash"));
 
@@ -194,16 +232,36 @@ mod tests {
         assert!(js.is_ok());
         let js = js.unwrap();
 
-        assert_eq!(js.len(), 1, "There should be one set of jobs for two packages on the same level in the tree: {:?}", js);
+        assert_eq!(
+            js.len(),
+            1,
+            "There should be one set of jobs for two packages on the same level in the tree: {:?}",
+            js
+        );
 
         let js = js.get(0).unwrap();
-        assert_eq!(js.set.len(), 2, "The jobset should contain exactly two jobs: {:?}", js);
+        assert_eq!(
+            js.set.len(),
+            2,
+            "The jobset should contain exactly two jobs: {:?}",
+            js
+        );
 
         let job = js.set.get(0).unwrap();
-        assert_eq!(*job.package.name(), pname("a"), "The job should be for the package 'a': {:?}", job);
+        assert_eq!(
+            *job.package.name(),
+            pname("a"),
+            "The job should be for the package 'a': {:?}",
+            job
+        );
 
         let job = js.set.get(1).unwrap();
-        assert_eq!(*job.package.name(), pname("b"), "The job should be for the package 'a': {:?}", job);
+        assert_eq!(
+            *job.package.name(),
+            pname("b"),
+            "The job should be for the package 'a': {:?}",
+            job
+        );
     }
 
     #[test]
@@ -239,7 +297,7 @@ mod tests {
         let r = tree.add_package(p1, &repo, progress);
         assert!(r.is_ok());
 
-        let image  = ImageName::from(String::from("test"));
+        let image = ImageName::from(String::from("test"));
         let phases = vec![PhaseName::from(String::from("testphase"))];
         let shebang = Shebang::from(String::from("#!/bin/bash"));
 
@@ -247,25 +305,47 @@ mod tests {
         assert!(js.is_ok());
         let js = js.unwrap();
 
-        assert_eq!(js.len(), 2, "There should be two set of jobs for two packages where one depends on the other: {:?}", js);
+        assert_eq!(
+            js.len(),
+            2,
+            "There should be two set of jobs for two packages where one depends on the other: {:?}",
+            js
+        );
 
         {
             let first_js = js.get(0).unwrap();
-            assert_eq!(first_js.set.len(), 1, "The first jobset should contain exactly one job: {:?}", js);
+            assert_eq!(
+                first_js.set.len(),
+                1,
+                "The first jobset should contain exactly one job: {:?}",
+                js
+            );
 
             let job = first_js.set.get(0).unwrap();
-            assert_eq!(*job.package.name(), pname("b"), "The job from the first set should be for the package 'b': {:?}", job);
+            assert_eq!(
+                *job.package.name(),
+                pname("b"),
+                "The job from the first set should be for the package 'b': {:?}",
+                job
+            );
         }
 
         {
             let second_js = js.get(1).unwrap();
-            assert_eq!(second_js.set.len(), 1, "The second jobset should contain exactly one job: {:?}", js);
+            assert_eq!(
+                second_js.set.len(),
+                1,
+                "The second jobset should contain exactly one job: {:?}",
+                js
+            );
 
             let job = second_js.set.get(0).unwrap();
-            assert_eq!(*job.package.name(), pname("a"), "The job should be for the package 'a': {:?}", job);
+            assert_eq!(
+                *job.package.name(),
+                pname("a"),
+                "The job should be for the package 'a': {:?}",
+                job
+            );
         }
-
     }
-
 }
-