Allow group to have named depenencies (#50)

With this change, a group will be able to define a list of "needs"
that are names of other groups. When executing, groups will run their
dependencies first. In the event a dependency fails, the group will not
run.

When a "path" fails, if other paths don't depend on the failing group,
then they will continue to run. This will allow as much work as possible
to happen.

The order that groups will execute will now be stable, and list (both
root and doctor)
let the user know the calculated run order.

Closes #45
Closes #39
Closes #46

Author: ethankhall

Cargo.lock

@@ -17,6 +17,9 @@ metadata:
   name: node
 spec:
   description: Check node is ready.
+  needs:
+    - python
+    - brew
   actions:
     - description: Node Version
       check:
@@ -65,6 +68,7 @@ To target a script relative to the group it must start with `.`, and giving a re
 ## Schema
 
 - `.spec.action` a series of steps to check and fix for the group.
+- `.spec.needs[]` an array of names required before this group can run.
 - `.spec.action[].required` default true, when true action failing check & fix will stop all execution. 
 - `.spec.action[].check.paths` A list of globs to check for a change.
 - `.spec.action[].check.commands` A list of commands to execute, using the exit code to determine if changes are needed.

docs/docs/models/ScopeDoctorGroup.md

@@ -19,6 +19,7 @@ tokio = { version = "1", features = ["full"] }
 mockall = "0.12.1"
 educe = "0.5.11"
 derive_builder = "0.13.0"
+petgraph = "0.6.4"
 
 scope-lib = { path = "../scope-lib" }
 

scope-doctor/Cargo.toml

@@ -50,7 +50,7 @@ impl CacheResults {
     }
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Clone)]
 #[allow(clippy::enum_variant_names)]
 pub enum ActionRunResult {
     CheckSucceeded,
@@ -76,10 +76,20 @@ impl ActionRunResult {
     }
 }
 
+#[automock]
+#[async_trait::async_trait]
+pub trait DoctorActionRun: Send + Sync {
+    async fn run_action(&self) -> Result<ActionRunResult>;
+    fn required(&self) -> bool;
+    fn name(&self) -> String;
+    fn help_text(&self) -> Option<String>;
+    fn help_url(&self) -> Option<String>;
+}
+
 #[derive(Educe, Builder)]
 #[educe(Debug)]
 #[builder(setter(into))]
-pub struct DoctorActionRun {
+pub struct DefaultDoctorActionRun {
     pub model: ModelRoot<DoctorGroup>,
     pub action: DoctorGroupAction,
     pub working_dir: PathBuf,
@@ -91,9 +101,10 @@ pub struct DoctorActionRun {
     pub glob_walker: Arc<dyn GlobWalker>,
 }
 
-impl DoctorActionRun {
+#[async_trait::async_trait]
+impl DoctorActionRun for DefaultDoctorActionRun {
     #[instrument(skip_all, fields(model.name = self.model.name(), action.name = self.action.name, action.description = self.action.description ))]
-    pub async fn run_action(&self) -> Result<ActionRunResult> {
+    async fn run_action(&self) -> Result<ActionRunResult> {
         let check_status = self.evaluate_checks().await?;
         if check_status == CacheResults::FixNotRequired {
             return Ok(ActionRunResult::CheckSucceeded);
@@ -124,6 +135,24 @@ impl DoctorActionRun {
         Ok(ActionRunResult::CheckFailedFixSucceedVerifySucceed)
     }
 
+    fn required(&self) -> bool {
+        self.action.required
+    }
+
+    fn name(&self) -> String {
+        self.action.name.to_string()
+    }
+
+    fn help_text(&self) -> Option<String> {
+        self.action.fix.help_text.clone()
+    }
+
+    fn help_url(&self) -> Option<String> {
+        self.action.fix.help_url.clone()
+    }
+}
+
+impl DefaultDoctorActionRun {
     async fn update_caches(&self) {
         if let Some(cache_path) = &self.action.check.files {
             let result = self
@@ -268,7 +297,7 @@ impl DoctorActionRun {
 
 #[automock]
 #[async_trait]
-pub trait GlobWalker {
+pub trait GlobWalker: Send + Sync {
     async fn have_globs_changed(
         &self,
         base_dir: &Path,
@@ -337,21 +366,18 @@ impl GlobWalker for DefaultGlobWalker {
 }
 
 #[cfg(test)]
-mod tests {
-    use crate::check::{ActionRunResult, DoctorActionRun, MockGlobWalker, RuntimeError};
+pub(crate) mod tests {
+    use crate::check::{
+        ActionRunResult, DefaultDoctorActionRun, DoctorActionRun, MockGlobWalker, RuntimeError,
+    };
     use crate::file_cache::{FileCache, NoOpCache};
+    use crate::tests::build_root_model;
     use anyhow::{anyhow, Result};
-    use scope_lib::prelude::{
-        DoctorGroup, DoctorGroupAction, DoctorGroupActionBuilder, DoctorGroupActionCheckBuilder,
-        DoctorGroupActionCommand, DoctorGroupActionFixBuilder, DoctorGroupBuilder,
-        DoctorGroupCachePath, MockExecutionProvider, ModelMetadataBuilder, ModelRoot,
-        ModelRootBuilder, OutputCaptureBuilder,
-    };
-    use std::collections::BTreeMap;
+    use scope_lib::prelude::*;
     use std::path::PathBuf;
     use std::sync::Arc;
 
-    fn build_run_fail_fix_succeed_action() -> DoctorGroupAction {
+    pub fn build_run_fail_fix_succeed_action() -> DoctorGroupAction {
         DoctorGroupActionBuilder::default()
             .description("a test action")
             .name("action")
@@ -373,7 +399,7 @@ mod tests {
             .unwrap()
     }
 
-    fn build_file_fix_action() -> DoctorGroupAction {
+    pub fn build_file_fix_action() -> DoctorGroupAction {
         DoctorGroupActionBuilder::default()
             .description("a test action")
             .name("action")
@@ -395,30 +421,7 @@ mod tests {
             .unwrap()
     }
 
-    fn make_model(actions: Vec<DoctorGroupAction>) -> ModelRoot<DoctorGroup> {
-        let group = DoctorGroupBuilder::default()
-            .description("a description")
-            .actions(actions)
-            .build()
-            .unwrap();
-
-        ModelRootBuilder::default()
-            .api_version("fake")
-            .kind("fake-kind")
-            .metadata(
-                ModelMetadataBuilder::default()
-                    .name("fake-model")
-                    .annotations(BTreeMap::default())
-                    .labels(BTreeMap::default())
-                    .build()
-                    .unwrap(),
-            )
-            .spec(group)
-            .build()
-            .unwrap()
-    }
-
-    fn command_result(
+    pub fn command_result(
         mock: &mut MockExecutionProvider,
         command: &'static str,
         expected_results: Vec<i32>,
@@ -437,16 +440,16 @@ mod tests {
             });
     }
 
-    fn setup_test(
+    pub fn setup_test(
         actions: Vec<DoctorGroupAction>,
         exec_runner: MockExecutionProvider,
         glob_walker: MockGlobWalker,
-    ) -> DoctorActionRun {
-        let model = make_model(actions.clone());
+    ) -> DefaultDoctorActionRun {
+        let model = build_root_model(actions.clone());
         let path = PathBuf::from("/tmp/foo");
         let file_cache: Arc<dyn FileCache> = Arc::<NoOpCache>::default();
 
-        DoctorActionRun {
+        DefaultDoctorActionRun {
             model,
             action: actions[0].clone(),
             working_dir: path,

scope-doctor/src/check.rs

@@ -1,17 +1,36 @@
+use crate::runner::compute_group_order;
 use anyhow::Result;
 use clap::Args;
-use colored::*;
-use scope_lib::prelude::{FoundConfig, HelpMetadata, ScopeModel};
+use scope_lib::prelude::{DoctorGroup, FoundConfig, ModelRoot};
+use scope_lib::print_details;
+use std::collections::{BTreeSet, VecDeque};
 use tracing::info;
 
 #[derive(Debug, Args)]
 pub struct DoctorListArgs {}
 
 pub async fn doctor_list(found_config: &FoundConfig, _args: &DoctorListArgs) -> Result<()> {
     info!(target: "user", "Available checks that will run");
-    info!(target: "user", "{:<20}{:<40}", "Name".white().bold(), "Description".white().bold());
-    for check in found_config.doctor_group.values() {
-        info!(target: "user", "{:<20}{:<40}", check.name().white().bold(), check.spec.description());
-    }
+    let order = generate_doctor_list(found_config);
+    print_details(&found_config.working_dir, order);
     Ok(())
 }
+
+pub fn generate_doctor_list(found_config: &FoundConfig) -> Vec<&ModelRoot<DoctorGroup>> {
+    let all_keys = BTreeSet::from_iter(found_config.doctor_group.keys().map(|x| x.to_string()));
+    let all_paths = compute_group_order(&found_config.doctor_group, all_keys);
+
+    let mut group_order = VecDeque::new();
+    for path in all_paths {
+        for group in path {
+            if !group_order.contains(&group) {
+                group_order.push_back(group);
+            }
+        }
+    }
+
+    group_order
+        .iter()
+        .map(|name| found_config.doctor_group.get(name).unwrap())
+        .collect()
+}

scope-doctor/src/commands/list.rs

@@ -3,5 +3,5 @@ mod list;
 mod run;
 
 pub use init::{doctor_init, DoctorInitArgs};
-pub use list::{doctor_list, DoctorListArgs};
+pub use list::{doctor_list, generate_doctor_list, DoctorListArgs};
 pub use run::{doctor_run, DoctorRunArgs};