Comment out or remove unused sections

Allows for a better tracking of group start and end to update the
progress window

boot_diags/src/app.rs

@@ -236,7 +236,7 @@ impl App {
         // Late init
         self.system32 = if cfg!(windows) {
             if let Ok(path) = env::var("SYSTEMROOT") {
-                format!("{path}/System32")
+                format!("{path}\\System32")
             } else {
                 self.action_tx.send(Action::Error(String::from(
                     "ERROR\n\n\nFailed to find SYSTEMROOT",
@@ -400,32 +400,21 @@ impl App {
                     self.action_tx.send(build_right_items(self))?;
                     self.action_tx.send(Action::Select(None, None))?;
                 }
-                Action::TaskStart(ref task_type) => {
+                Action::TaskGroupStart(ref title) => {
                     if self.cur_mode == Mode::BootScan {
-                        let title: Option<String> = match task_type {
-                            TaskType::CommandWait(cmd, _args) => {
-                                let cmd_str = cmd.to_string_lossy().into_owned();
-                                let diag_type = diags::get_type(&cmd_str);
-                                Some(format!("{diag_type}"))
-                            }
-                            TaskType::TestPaths(_) => Some(String::from("Critical Paths")),
-                            _ => None,
-                        };
-                        if let Some(title) = title {
-                            info!("{:?}", self.task_groups.front());
-                            if self.task_groups.front().is_some() {
-                                if self.task_groups.front().unwrap().is_some() {
-                                    // None here means that we're in the middle of a group of tasks
-                                    // i.e. don't start a new diag line
-                                    self.action_tx.send(Action::DiagStartLine {
-                                        text: title.clone(),
-                                    })?;
-                                }
-                            }
-                            if !self.diag_groups.contains(&title) {
-                                self.diag_groups.update(title, None, None);
+                        info!("TaskGroup: {:?}", self.task_groups.front());
+                        if self.task_groups.front().is_some() {
+                            if self.task_groups.front().unwrap().is_some() {
+                                // None here means that we're in the middle of a group of tasks
+                                // i.e. don't start a new diag line
+                                self.action_tx.send(Action::DiagStartLine {
+                                    text: title.clone(),
+                                })?;
                             }
                         }
+                        if !self.diag_groups.contains(&title) {
+                            self.diag_groups.update(title.to_owned(), None, None);
+                        }
                     }
                 }
                 Action::TasksComplete => {
@@ -534,12 +523,12 @@ impl App {
                                 if passed {
                                     self.action_tx.send(Action::DiagEndLine {
                                         result: DiagResult::Pass,
-                                        text: String::from("Maybe?"),
+                                        text: String::from("Pass?"),
                                     })?;
                                 } else {
                                     self.action_tx.send(Action::DiagEndLine {
                                         result: DiagResult::Fail,
-                                        text: String::from("Nope?"),
+                                        text: String::from("Fail?"),
                                     })?;
                                 };
                             }
@@ -548,14 +537,14 @@ impl App {
                         // If title was set but there wasn't a result
                         self.action_tx.send(Action::DiagEndLine {
                             result: DiagResult::Warn,
-                            text: String::from("Yellow result?"),
+                            text: String::from("Yellow no result?"),
                         })?;
                     }
                 } else {
                     // title was not set
                     self.action_tx.send(Action::DiagEndLine {
                         result: DiagResult::Warn,
-                        text: String::from("Yellow title?"),
+                        text: String::from("Yellow no title?"),
                     })?;
                 }
             }
@@ -619,51 +608,50 @@ impl App {
 
                 // BCD
                 if !letter_boot.is_empty() {
-                    self.tasks.add(TaskType::CommandWait(
-                        PathBuf::from(format!("{}\\bcdedit.exe", &self.system32)),
-                        vec![
-                            String::from("/store"),
-                            format!(
-                                "{letter_boot}:{}\\Boot\\BCD",
-                                if table_type == PartitionTableType::Guid {
-                                    "\\EFI\\Microsoft"
-                                } else {
-                                    ""
-                                }
-                            ),
-                            String::from("/enum"),
-                        ],
-                    ));
-                    self.task_groups
-                        .push_back(Some(format!("{}", diags::Type::BootConfigData)));
+                    self.tasks.add_group(
+                        "Boot Files",
+                        vec![TaskType::CommandWait(
+                            PathBuf::from(format!("{}\\bcdedit.exe", &self.system32)),
+                            vec![
+                                String::from("/store"),
+                                format!(
+                                    "{letter_boot}:{}\\Boot\\BCD",
+                                    if table_type == PartitionTableType::Guid {
+                                        "\\EFI\\Microsoft"
+                                    } else {
+                                        ""
+                                    }
+                                ),
+                                String::from("/enum"),
+                            ],
+                        )],
+                    );
+                    self.task_groups.push_back(Some(String::from("Boot Files")));
                 }
 
                 // Bitlocker
-                self.tasks.add(TaskType::CommandWait(
-                    PathBuf::from(format!("{}\\manage-bde.exe", &self.system32)),
-                    vec![String::from("-status"), format!("{letter_os}:")],
-                ));
-                self.task_groups.push_back(None);
-                self.tasks.add(TaskType::CommandWait(
-                    PathBuf::from(format!("{}\\manage-bde.exe", &self.system32)),
+                self.tasks.add_group(
+                    "Bitlocker",
                     vec![
-                        String::from("-protectors"),
-                        String::from("-get"),
-                        format!("{letter_os}:"),
+                        TaskType::CommandWait(
+                            PathBuf::from(format!("{}\\manage-bde.exe", &self.system32)),
+                            vec![String::from("-status"), format!("{letter_os}:")],
+                        ),
+                        TaskType::CommandWait(
+                            PathBuf::from(format!("{}\\manage-bde.exe", &self.system32)),
+                            vec![
+                                String::from("-protectors"),
+                                String::from("-get"),
+                                format!("{letter_os}:"),
+                            ],
+                        ),
                     ],
-                ));
-                self.task_groups
-                    .push_back(Some(format!("{}", diags::Type::Bitlocker)));
+                );
+                self.task_groups.push_back(Some(String::from("Bitlocker")));
 
                 // Filesystem Health
-                self.tasks.add(TaskType::CommandWait(
-                    PathBuf::from(format!("{}\\chkdsk.exe", &self.system32)),
-                    vec![format!("{letter_os}:")],
-                ));
-                self.task_groups.push_back(None);
-
-                // Files/Folders
                 let paths: Vec<PathBuf> = [
+                    // Files/Folders
                     "Users",
                     "Program Files",
                     "Program Files (x86)",
@@ -673,62 +661,72 @@ impl App {
                 .iter()
                 .map(|s| PathBuf::from(format!("{letter_os}:\\{s}")))
                 .collect();
-                self.tasks.add(TaskType::TestPaths(paths));
-                self.task_groups
-                    .push_back(Some(format!("{}", diags::Type::FileSystem)));
+                self.tasks.add_group(
+                    "Filesystem",
+                    vec![
+                        TaskType::CommandWait(
+                            PathBuf::from(format!("{}\\chkdsk.exe", &self.system32)),
+                            vec![format!("{letter_os}:")],
+                        ),
+                        TaskType::TestPaths(paths),
+                    ],
+                );
+                self.task_groups.push_back(Some(String::from("Filesystem")));
 
                 // DISM Health
-                self.tasks.add(TaskType::CommandWait(
-                    PathBuf::from(format!("{}\\dism.exe", &self.system32)),
-                    vec![format!("{letter_os}:")],
-                ));
+                self.tasks.add_group(
+                    "System Files",
+                    vec![TaskType::CommandWait(
+                        PathBuf::from(format!("{}\\dism.exe", &self.system32)),
+                        vec![format!("{letter_os}:")],
+                    )],
+                );
                 self.task_groups
-                    .push_back(Some(format!("{}", diags::Type::System)));
+                    .push_back(Some(String::from("System Files")));
 
                 // Registry
-                self.tasks.add(TaskType::CommandWait(
-                    PathBuf::from(format!("{}\\reg.exe", &self.system32)),
+                self.tasks.add_group(
+                    "Registry",
                     vec![
-                        String::from("load"),
-                        String::from("HKLM\\TmpSoftware"),
-                        format!("{letter_os}:\\Windows\\System32\\config\\SOFTWARE"),
+                        TaskType::CommandWait(
+                            PathBuf::from(format!("{}\\reg.exe", &self.system32)),
+                            vec![
+                                String::from("load"),
+                                String::from("HKLM\\TmpSoftware"),
+                                format!("{letter_os}:\\Windows\\System32\\config\\SOFTWARE"),
+                            ],
+                        ),
+                        TaskType::CommandWait(
+                            PathBuf::from(format!("{}\\reg.exe", &self.system32)),
+                            vec![
+                                String::from("load"),
+                                String::from("HKLM\\TmpSystem"),
+                                format!("{letter_os}:\\Windows\\System32\\config\\SYSTEM"),
+                            ],
+                        ),
+                        TaskType::CommandWait(
+                            PathBuf::from(format!("{}\\reg.exe", &self.system32)),
+                            vec![
+                                String::from("load"),
+                                String::from("HKU\\TmpDefault"),
+                                format!("{letter_os}:\\Windows\\System32\\config\\DEFAULT"),
+                            ],
+                        ),
+                        TaskType::CommandWait(
+                            PathBuf::from(format!("{}\\reg.exe", &self.system32)),
+                            vec![String::from("unload"), String::from("HKLM\\TmpSoftware")],
+                        ),
+                        TaskType::CommandWait(
+                            PathBuf::from(format!("{}\\reg.exe", &self.system32)),
+                            vec![String::from("unload"), String::from("HKLM\\TmpSystem")],
+                        ),
+                        TaskType::CommandWait(
+                            PathBuf::from(format!("{}\\reg.exe", &self.system32)),
+                            vec![String::from("unload"), String::from("HKU\\TmpDefault")],
+                        ),
                     ],
-                ));
-                self.task_groups.push_back(None);
-                self.tasks.add(TaskType::CommandWait(
-                    PathBuf::from(format!("{}\\reg.exe", &self.system32)),
-                    vec![
-                        String::from("load"),
-                        String::from("HKLM\\TmpSystem"),
-                        format!("{letter_os}:\\Windows\\System32\\config\\SYSTEM"),
-                    ],
-                ));
-                self.task_groups.push_back(None);
-                self.tasks.add(TaskType::CommandWait(
-                    PathBuf::from(format!("{}\\reg.exe", &self.system32)),
-                    vec![
-                        String::from("load"),
-                        String::from("HKU\\TmpDefault"),
-                        format!("{letter_os}:\\Windows\\System32\\config\\DEFAULT"),
-                    ],
-                ));
-                self.task_groups.push_back(None);
-                self.tasks.add(TaskType::CommandWait(
-                    PathBuf::from(format!("{}\\reg.exe", &self.system32)),
-                    vec![String::from("unload"), String::from("HKLM\\TmpSoftware")],
-                ));
-                self.task_groups.push_back(None);
-                self.tasks.add(TaskType::CommandWait(
-                    PathBuf::from(format!("{}\\reg.exe", &self.system32)),
-                    vec![String::from("unload"), String::from("HKLM\\TmpSystem")],
-                ));
-                self.task_groups.push_back(None);
-                self.tasks.add(TaskType::CommandWait(
-                    PathBuf::from(format!("{}\\reg.exe", &self.system32)),
-                    vec![String::from("unload"), String::from("HKU\\TmpDefault")],
-                ));
-                self.task_groups
-                    .push_back(Some(format!("{}", diags::Type::Registry)));
+                );
+                self.task_groups.push_back(Some(String::from("Registry")));
                 self.tasks.add(TaskType::Sleep); // NOTE: DELETEME
             }
         }
@@ -910,6 +908,7 @@ fn build_left_items(app: &App) -> Action {
             let (new_title, _) = get_mode_strings(app.cur_mode);
             title = new_title;
             app.diag_groups.get().iter().for_each(|group| {
+                info!("BootDiags Group: {:?}", group);
                 items.push(if group.passed {
                     group.title.clone()
                 } else {

boot_diags/src/components/progress.rs

@@ -21,13 +21,11 @@ use ratatui::{
     text::{Line, Span},
     widgets::{Block, Borders, Clear, Paragraph},
 };
-use tokio::sync::mpsc::UnboundedSender;
 use tracing::info;
 
 use core::{
     action::{Action, DiagResult},
     components::Component,
-    config::Config,
     state::Mode,
 };
 
@@ -42,16 +40,12 @@ impl ProgressLine {
     pub fn len_name(&self) -> usize {
         self.name.chars().count()
     }
-
-    pub fn len_text(&self) -> usize {
-        self.text.chars().count()
-    }
 }
 
 #[derive(Default, Debug, Clone)]
 pub struct Progress {
-    command_tx: Option<UnboundedSender<Action>>,
-    config: Config,
+    // command_tx: Option<UnboundedSender<Action>>,
+    // config: Config,
     lines: Vec<ProgressLine>,
     mode: Mode,
 }
@@ -62,15 +56,15 @@ impl Progress {
         Self::default()
     }
 
-    fn register_action_handler(&mut self, tx: UnboundedSender<Action>) -> Result<()> {
-        self.command_tx = Some(tx);
-        Ok(())
-    }
+    // fn register_action_handler(&mut self, tx: UnboundedSender<Action>) -> Result<()> {
+    //     self.command_tx = Some(tx);
+    //     Ok(())
+    // }
 
-    fn register_config_handler(&mut self, config: Config) -> Result<()> {
-        self.config = config;
-        Ok(())
-    }
+    // fn register_config_handler(&mut self, config: Config) -> Result<()> {
+    //     self.config = config;
+    //     Ok(())
+    // }
 }
 
 impl Component for Progress {
@@ -85,7 +79,10 @@ impl Component for Progress {
                 });
             }
             Action::DiagEndLine { result, text } => {
-                info!("Caught Action::DiagEndLine");
+                info!(
+                    "Caught Action::DiagEndLine {{ {}, \"{}\" }}",
+                    &result, &text
+                );
                 if let Some(line) = self.lines.last_mut() {
                     line.result = result;
                     line.text = text;

boot_diags/src/components/results.rs

@@ -15,14 +15,13 @@
 //
 use color_eyre::Result;
 use ratatui::{Frame, layout::Rect};
-use tokio::sync::mpsc::UnboundedSender;
 
-use core::{action::Action, components::Component, config::Config};
+use core::{action::Action, components::Component};
 
 #[derive(Default, Debug, Clone)]
 pub struct Results {
-    command_tx: Option<UnboundedSender<Action>>,
-    config: Config,
+    // command_tx: Option<UnboundedSender<Action>>,
+    // config: Config,
 }
 
 impl Results {
@@ -31,23 +30,23 @@ impl Results {
         Self::default()
     }
 
-    fn register_action_handler(&mut self, tx: UnboundedSender<Action>) -> Result<()> {
-        self.command_tx = Some(tx);
-        Ok(())
-    }
+    // fn register_action_handler(&mut self, tx: UnboundedSender<Action>) -> Result<()> {
+    //     self.command_tx = Some(tx);
+    //     Ok(())
+    // }
 
-    fn register_config_handler(&mut self, config: Config) -> Result<()> {
-        self.config = config;
-        Ok(())
-    }
+    // fn register_config_handler(&mut self, config: Config) -> Result<()> {
+    //     self.config = config;
+    //     Ok(())
+    // }
 }
 
 impl Component for Results {
-    fn update(&mut self, action: Action) -> Result<Option<Action>> {
+    fn update(&mut self, _action: Action) -> Result<Option<Action>> {
         Ok(None)
     }
 
-    fn draw(&mut self, frame: &mut Frame, area: Rect) -> Result<()> {
+    fn draw(&mut self, _frame: &mut Frame, _area: Rect) -> Result<()> {
         Ok(())
     }
 }

boot_diags/src/diags.rs

@@ -79,7 +79,7 @@ impl Groups {
                 title.clone(),
                 Line {
                     title,
-                    passed: passed.unwrap_or(false),
+                    passed: passed.unwrap_or(true),
                     info: info_list,
                 },
             );

core/src/action.rs

@@ -21,7 +21,6 @@ use crate::{
     line::DVLine,
     state::Mode,
     system::disk::Disk,
-    tasks::TaskType,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq, Display, Serialize, Deserialize)]
@@ -44,7 +43,8 @@ pub enum Action {
     ScanDisks,
     Select(Option<usize>, Option<usize>), // indicies for (source, dest) etc
     SelectRight(Option<usize>, Option<usize>), // indicies for right info pane
-    TaskStart(TaskType),
+    TaskGroupStart(String),
+    TaskGroupEnd,
     TasksComplete,
     UpdateDiskList(Vec<Disk>),
     UpdateFooter(String),

core/src/tasks.rs

@@ -52,6 +52,8 @@ pub enum TaskType {
     TestPaths(Vec<PathBuf>),
     UpdateDestDisk(usize), // (disk_index)
     UpdateDiskList,
+    GroupStart { label: String },
+    GroupEnd,
 }
 
 impl fmt::Display for TaskType {
@@ -72,6 +74,8 @@ impl fmt::Display for TaskType {
             TaskType::TestPaths(_) => write!(f, "TestPaths"),
             TaskType::UpdateDestDisk(_) => write!(f, "UpdateDestDisk"),
             TaskType::UpdateDiskList => write!(f, "UpdateDiskList"),
+            TaskType::GroupStart { label } => write!(f, "GroupStart({})", &label),
+            TaskType::GroupEnd => write!(f, "GroupEnd"),
         }
     }
 }
@@ -127,6 +131,17 @@ impl Tasks {
         self.task_list.push_back(Task::new(task_type));
     }
 
+    pub fn add_group(&mut self, group_label: &str, group_tasks: Vec<TaskType>) {
+        info!("Adding task group: {group_label}");
+        self.task_list.push_back(Task::new(TaskType::GroupStart {
+            label: group_label.to_string(),
+        }));
+        group_tasks.into_iter().for_each(|task| {
+            self.task_list.push_back(Task::new(task));
+        });
+        self.task_list.push_back(Task::new(TaskType::GroupEnd));
+    }
+
     #[must_use]
     pub fn idle(&self) -> bool {
         self.cur_handle.is_none()
@@ -173,8 +188,6 @@ impl Tasks {
         self.cur_task = self.task_list.pop_front();
         if let Some(task) = self.cur_task.take() {
             let task_tx = self.task_tx.clone();
-            self.action_tx
-                .send(Action::TaskStart(task.task_type.clone()))?;
             match task.task_type {
                 TaskType::CommandNoWait(ref cmd_path, ref cmd_args) => {
                     self.cur_handle = None;
@@ -235,6 +248,10 @@ impl Tasks {
                         }
                     }));
                 }
+                TaskType::GroupStart { ref label } => {
+                    self.action_tx.send(Action::TaskGroupStart(label.clone()))?
+                }
+                TaskType::GroupEnd => self.action_tx.send(Action::TaskGroupEnd)?,
             }
             // Done
             self.cur_task.replace(task);