Refactor, introduce faker module

Author: ranfdev

src/application.rs

@@ -27,9 +27,8 @@ use gettextrs::gettext;
 use gtk::{gio, glib};
 
 use crate::config::VERSION;
-use crate::distrobox::{
-    CommandRunner, Distrobox, DistroboxCommandRunnerResponse 
-};
+use crate::distrobox::{Distrobox, DistroboxCommandRunnerResponse, FlatpakCommandRunner};
+use crate::fakers::{CommandRunner, RealCommandRunner};
 use crate::root_store::RootStore;
 use crate::DistroShelfWindow;
 
@@ -223,7 +222,9 @@ impl DistroShelfApplication {
             }
             _ => {
                 if Self::get_is_in_flatpak() {
-                    CommandRunner::new_flatpak_real()
+                    CommandRunner::new(Rc::new(FlatpakCommandRunner::new(Rc::new(
+                        RealCommandRunner::new(),
+                    ))))
                 } else {
                     CommandRunner::new_real()
                 }

src/container.rs

@@ -1,9 +1,10 @@
 use crate::{
-    distrobox::{Command, ContainerInfo, ExportableApp, Status},
+    distrobox::{ContainerInfo, ExportableApp, Status},
     distrobox_task::DistroboxTask,
     known_distros::{known_distro_by_image, KnownDistro},
     remote_resource::RemoteResource,
     root_store::RootStore,
+    fakers::Command
 };
 
 use gtk::{

src/distrobox/mod.rs

@@ -1,57 +1,46 @@
 use std::{
-    cell::{LazyCell, RefCell}, collections::BTreeMap, io, path::{Path, PathBuf}, process::Output, rc::Rc, str::FromStr
+    cell::LazyCell, collections::BTreeMap, future::Future, io, path::{Path, PathBuf}, pin::Pin, process::Output, rc::Rc, str::FromStr
 };
 use tracing::{debug, error, info, warn};
+use crate::fakers::{CommandRunner, NullCommandRunnerBuilder, Command, Child, InnerCommandRunner, FdMode};
 
-mod command;
-mod command_runner;
 mod desktop_file;
 
-pub use command::*;
-pub use command_runner::*;
 pub use desktop_file::*;
 
-#[derive(Default, Clone, Debug)]
-pub struct OutputTracker<T> {
-    store: Rc<RefCell<Option<Vec<T>>>>,
-}
 
-impl<T> OutputTracker<T> {
-    pub fn new() -> Self {
-        OutputTracker {
-            store: Rc::new(RefCell::new(None)),
-        }
+#[derive(Clone)]
+pub struct FlatpakCommandRunner {
+    pub command_runner: Rc<dyn InnerCommandRunner>,
+}
+impl FlatpakCommandRunner {
+    pub fn new(command_runner: Rc<dyn InnerCommandRunner>) -> Self {
+        FlatpakCommandRunner { command_runner }
     }
-    pub fn len(&self) -> usize {
-        if let Some(v) = &*self.store.borrow() {
-            v.len()
-        } else {
-            0
-        }
+
+    pub fn wrap_flatpak_cmd(mut prev: Command) -> Command {
+        let mut args = vec!["--host".into(), prev.program];
+        args.extend(prev.args);
+
+        prev.args = args;
+        prev.program = "flatpak-spawn".into();
+        prev
     }
 }
 
-impl<T: Clone + std::fmt::Debug> OutputTracker<T> {
-    pub fn enable(&self) {
-        let mut inner = self.store.borrow_mut();
-        if inner.is_none() {
-            *inner = Some(vec![]);
-        }
-    }
-    pub fn push(&self, item: T) {
-        if let Some(v) = &mut *self.store.borrow_mut() {
-            v.push(item);
-        }
+impl InnerCommandRunner for FlatpakCommandRunner {
+    fn spawn(&self, command: Command) -> io::Result<Box<dyn Child + Send>> {
+        self.command_runner.spawn(Self::wrap_flatpak_cmd(command))
     }
-    pub fn items(&self) -> Vec<T> {
-        if let Some(v) = &*self.store.borrow() {
-            v.clone()
-        } else {
-            vec![]
-        }
+    fn output(
+        &self,
+        command: Command,
+    ) -> Pin<Box<dyn Future<Output = io::Result<std::process::Output>>>> {
+        self.command_runner.output(Self::wrap_flatpak_cmd(command))
     }
 }
 
+
 pub struct Distrobox {
     cmd_runner: CommandRunner,
 }
@@ -497,7 +486,8 @@ impl Distrobox {
     }
 
     pub fn cmd_spawn(&self, mut cmd: Command) -> Result<Box<dyn Child + Send>, Error> {
-        wrap_capture_cmd(&mut cmd);
+        cmd.stdout = FdMode::Pipe;
+        cmd.stderr = FdMode::Pipe;
 
         let program = cmd.program.to_string_lossy().to_string();
         let args = cmd
@@ -520,7 +510,8 @@ impl Distrobox {
     }
 
     async fn cmd_output(&self, mut cmd: Command) -> Result<Output, Error> {
-        wrap_capture_cmd(&mut cmd);
+        cmd.stdout = FdMode::Pipe;
+        cmd.stderr = FdMode::Pipe;
 
         let program = cmd.program.to_string_lossy().to_string();
         let args = cmd

src/distrobox_task.rs

@@ -11,7 +11,7 @@ use std::cell::RefCell;
 use std::future::Future;
 use tracing::{debug, error, info, warn};
 
-use crate::distrobox::Child;
+use crate::fakers::Child;
 
 mod imp {
     use super::*;

src/distrobox/command.rs src/fakers/command.rssrc/distrobox/command.rs renamed to src/fakers/command.rs

@@ -107,18 +107,3 @@ impl From<Command> for async_process::Command {
         cmd
     }
 }
-
-pub fn wrap_flatpak_cmd(mut prev: Command) -> Command {
-    let mut args = vec!["--host".into(), prev.program];
-    args.extend(prev.args);
-
-    prev.args = args;
-    prev.program = "flatpak-spawn".into();
-    prev
-}
-
-pub fn wrap_capture_cmd(cmd: &mut Command) -> &mut Command {
-    cmd.stdout = FdMode::Pipe;
-    cmd.stderr = FdMode::Pipe;
-    cmd
-}

src/distrobox/command_runner.rs src/fakers/command_runner.rssrc/distrobox/command_runner.rs renamed to src/fakers/command_runner.rs

@@ -5,15 +5,14 @@ use std::{
     collections::HashMap, future::Future, io::{self}, os::unix::process::ExitStatusExt, pin::Pin, process::ExitStatus, rc::Rc
 };
 
-use crate::distrobox::{Command, OutputTracker};
+use crate::fakers::{OutputTracker, Command};
+
 use async_process::{Command as AsyncCommand, Output};
 use futures::{
     io::{AsyncRead, AsyncWrite, Cursor},
     FutureExt,
 };
 
-use super::wrap_flatpak_cmd;
-
 
 #[derive(Debug, Clone)]
 pub enum CommandRunnerEvent {
@@ -59,11 +58,6 @@ impl CommandRunner {
     pub fn new_real() -> Self {
         CommandRunner::new(Rc::new(RealCommandRunner {}))
     }
-    pub fn new_flatpak_real() -> Self {
-        CommandRunner::new(Rc::new(FlatpakCommandRunner::new(
-            Rc::new(RealCommandRunner {}),
-        )))
-    }
 
     pub fn output_tracker(&self) -> OutputTracker<CommandRunnerEvent> {
         self.output_tracker.enable();
@@ -117,6 +111,11 @@ pub trait InnerCommandRunner {
 
 #[derive(Clone, Debug)]
 pub struct RealCommandRunner {}
+impl RealCommandRunner {
+    pub fn new() -> Self {
+        RealCommandRunner {}
+    }
+}
 
 impl InnerCommandRunner for RealCommandRunner {
     fn spawn(&self, command: Command) -> io::Result<Box<dyn Child + Send>> {
@@ -132,27 +131,6 @@ impl InnerCommandRunner for RealCommandRunner {
     }
 }
 
-#[derive(Clone)]
-pub struct FlatpakCommandRunner {
-    pub command_runner: Rc<dyn InnerCommandRunner>,
-}
-impl FlatpakCommandRunner {
-    pub fn new(command_runner: Rc<dyn InnerCommandRunner>) -> Self {
-        FlatpakCommandRunner { command_runner }
-    }
-}
-
-impl InnerCommandRunner for FlatpakCommandRunner {
-    fn spawn(&self, command: Command) -> io::Result<Box<dyn Child + Send>> {
-        self.command_runner.spawn(wrap_flatpak_cmd(command))
-    }
-    fn output(
-        &self,
-        command: Command,
-    ) -> Pin<Box<dyn Future<Output = io::Result<std::process::Output>>>> {
-        self.command_runner.output(wrap_flatpak_cmd(command))
-    }
-}
 
 
 #[derive(Default, Clone)]

src/fakers/mod.rs

@@ -0,0 +1,10 @@
+mod command_runner;
+mod output_tracker;
+mod command;
+
+pub use command::{Command, FdMode};
+pub use output_tracker::OutputTracker;
+pub use command_runner::{
+    CommandRunner, RealCommandRunner, NullCommandRunnerBuilder, Child, InnerCommandRunner,
+    CommandRunnerEvent
+};

src/fakers/output_tracker.rs

@@ -0,0 +1,42 @@
+use std::{cell::RefCell, rc::Rc};
+
+#[derive(Default, Clone, Debug)]
+pub struct OutputTracker<T> {
+    store: Rc<RefCell<Option<Vec<T>>>>,
+}
+
+impl<T> OutputTracker<T> {
+    pub fn new() -> Self {
+        OutputTracker {
+            store: Rc::new(RefCell::new(None)),
+        }
+    }
+    pub fn len(&self) -> usize {
+        if let Some(v) = &*self.store.borrow() {
+            v.len()
+        } else {
+            0
+        }
+    }
+}
+
+impl<T: Clone + std::fmt::Debug> OutputTracker<T> {
+    pub fn enable(&self) {
+        let mut inner = self.store.borrow_mut();
+        if inner.is_none() {
+            *inner = Some(vec![]);
+        }
+    }
+    pub fn push(&self, item: T) {
+        if let Some(v) = &mut *self.store.borrow_mut() {
+            v.push(item);
+        }
+    }
+    pub fn items(&self) -> Vec<T> {
+        if let Some(v) = &*self.store.borrow() {
+            v.clone()
+        } else {
+            vec![]
+        }
+    }
+}

src/known_distros.rs

@@ -1,4 +1,3 @@
-use crate::distrobox::Command;
 use glib::subclass::prelude::*;
 use gtk::glib;
 use gtk::glib::derived_properties;
@@ -9,6 +8,8 @@ use std::cell::RefCell;
 use std::collections::HashMap;
 use std::path::Path;
 
+use crate::fakers::Command;
+
 
 pub const DISTROS: LazyCell<
     HashMap<String, KnownDistro>,

src/main.rs

@@ -40,6 +40,7 @@ mod tasks_button;
 mod terminal_combo_row;
 mod welcome_view;
 mod window;
+mod fakers;
 pub use store::root_store;
 
 use self::application::DistroShelfApplication;