command : modularisation

src/command/command_sequence.rs

@@ -0,0 +1,36 @@
+use crate::command::Command;
+use crate::exit_code::ExitCode;
+
+pub struct CommandSequence {
+    command: Box<dyn Command>,
+    next_command: Option<Box<CommandSequence>>,
+}
+
+impl CommandSequence {
+    pub fn new(command: impl Command + 'static) -> Self {
+        Self {
+            command: Box::new(command),
+            next_command: None,
+        }
+    }
+
+    pub fn add(&mut self, command: impl Command + 'static) {
+        if self.next_command.is_none() {
+            self.next_command = Some(Box::new(CommandSequence::new(command)));
+        } else {
+            self.next_command.as_mut().unwrap().add(command);
+        }
+    }
+}
+
+impl Command for CommandSequence {
+    fn spawn(&mut self) -> ExitCode {
+        let mut exit_code = self.command.spawn();
+
+        if self.next_command.is_some() {
+            exit_code = self.next_command.as_mut().unwrap().spawn();
+        }
+
+        exit_code
+    }
+}

src/command/mod.rs

@@ -1,100 +1,8 @@
-use crate::error;
+pub mod command_sequence;
+pub mod unix_program;
 
-pub struct ExitCode {
+use crate::exit_code::ExitCode;
-    exit_code: u8,
-}
-
-impl ExitCode {
-    pub fn new(exit_code: u8) -> Self {
-        Self { exit_code }
-    }
-
-    pub fn get(&self) -> u8 {
-        self.exit_code
-    }
-
-    pub fn not_found() -> Self {
-        Self { exit_code: 127 }
-    }
-}
 
 pub trait Command {
     fn spawn(&mut self) -> ExitCode;
 }
-
-pub struct CommandSequence {
-    command: Box<dyn Command>,
-    next_command: Option<Box<CommandSequence>>,
-}
-
-impl CommandSequence {
-    pub fn new(command: impl Command + 'static) -> Self {
-        Self {
-            command: Box::new(command),
-            next_command: None,
-        }
-    }
-
-    pub fn add(&mut self, command: impl Command + 'static) {
-        if self.next_command.is_none() {
-            self.next_command = Some(Box::new(CommandSequence::new(command)));
-        } else {
-            self.next_command.as_mut().unwrap().add(command);
-        }
-    }
-}
-
-impl Command for CommandSequence {
-    fn spawn(&mut self) -> ExitCode {
-        let mut exit_code = self.command.spawn();
-
-        if self.next_command.is_some() {
-            exit_code = self.next_command.as_mut().unwrap().spawn();
-        }
-
-        exit_code
-    }
-}
-
-pub struct UnixProgram {
-    command: std::process::Command,
-}
-
-impl UnixProgram {
-    pub fn new(mut argv: Vec<String>) -> Self {
-        let program = argv.remove(0);
-        let mut command = std::process::Command::new(&program);
-        command.args(argv);
-
-        Self { command }
-    }
-}
-
-impl Command for UnixProgram {
-    fn spawn(&mut self) -> ExitCode {
-        let handle = self.command.spawn();
-
-        if handle.is_ok() {
-            let exit_code = handle
-                .unwrap()
-                .wait()
-                .expect("error waiting for the child")
-                .code()
-                .unwrap_or(1);
-
-            let exit_code = match u8::try_from(exit_code) {
-                Ok(code) => ExitCode::new(code),
-                Err(_e) => ExitCode::new(u8::MAX),
-            };
-
-            exit_code
-        } else {
-            let message = format!(
-                "{}: command not found",
-                self.command.get_program().to_str().unwrap()
-            );
-            error::print_error(message);
-            ExitCode::not_found()
-        }
-    }
-}

src/command/unix_program.rs

@@ -0,0 +1,46 @@
+use crate::command::Command;
+use crate::error::print_error;
+use crate::exit_code::ExitCode;
+
+pub struct UnixProgram {
+    command: std::process::Command,
+}
+
+impl UnixProgram {
+    pub fn new(mut argv: Vec<String>) -> Self {
+        let program = argv.remove(0);
+        let mut command = std::process::Command::new(&program);
+        command.args(argv);
+
+        Self { command }
+    }
+}
+
+impl Command for UnixProgram {
+    fn spawn(&mut self) -> ExitCode {
+        let handle = self.command.spawn();
+
+        if handle.is_ok() {
+            let exit_code = handle
+                .unwrap()
+                .wait()
+                .expect("error waiting for the child")
+                .code()
+                .unwrap_or(1);
+
+            let exit_code = match u8::try_from(exit_code) {
+                Ok(code) => ExitCode::new(code),
+                Err(_e) => ExitCode::new(u8::MAX),
+            };
+
+            exit_code
+        } else {
+            let message = format!(
+                "{}: command not found",
+                self.command.get_program().to_str().unwrap()
+            );
+            print_error(message);
+            ExitCode::not_found()
+        }
+    }
+}

src/control.rs

@@ -1,4 +1,5 @@
-use crate::command::{Command, ExitCode};
+use crate::command::Command;
+use crate::exit_code::ExitCode;
 use crate::interface::{get_user_input, print_prompt};
 use crate::parser::parse_command_line;
 

src/exit_code.rs

@@ -0,0 +1,17 @@
+pub struct ExitCode {
+    exit_code: u8,
+}
+
+impl ExitCode {
+    pub fn new(exit_code: u8) -> Self {
+        Self { exit_code }
+    }
+
+    pub fn get(&self) -> u8 {
+        self.exit_code
+    }
+
+    pub fn not_found() -> Self {
+        Self { exit_code: 127 }
+    }
+}

src/main.rs

@@ -1,6 +1,7 @@
 mod command;
 mod control;
 mod error;
+mod exit_code;
 mod interface;
 mod parser;
 

src/parser.rs

@@ -1,4 +1,5 @@
-use crate::command::{CommandSequence, UnixProgram};
+use crate::command::command_sequence::CommandSequence;
+use crate::command::unix_program::UnixProgram;
 
 pub fn parse_command_line(line: String) -> Option<CommandSequence> {
     let argv: Vec<String> = line.split_whitespace().map(|s| s.to_string()).collect();