Migrated shell

hw7/task2/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "task2"
+version = "0.1.0"
+authors = ["Joshua Rutschmann <joshua.rutschmann@gmx.de>"]
+
+[dependencies]

hw7/task2/src/lib.rs

@@ -0,0 +1,141 @@
+use std::io::{BufRead, Write};
+use std::str::FromStr;
+use std::env;
+use std::ffi::OsString;
+
+mod shellerror;
+
+#[derive(PartialEq, Debug)]
+pub enum Command {
+    Empty,
+    Exit,
+    Cd(Option<OsString>),
+}
+
+#[derive(PartialEq, Debug)]
+pub struct CommandNotFoundError;
+
+impl FromStr for Command {
+    type Err = CommandNotFoundError;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+
+        let mut parts = s.split_whitespace();
+
+        match parts.next() {
+            Some("exit") => Ok(Command::Exit),
+            Some("cd") => Ok(Command::parse_cd(parts.next())),
+            Some(cmd) => {
+                //For use in next homework, to execute programs.
+                let _ = cmd;
+                Err(CommandNotFoundError)
+            }
+            None => Ok(Command::Empty),
+        }
+    }
+}
+
+
+impl Command {
+    /// If the passed String exists, set the path of the Cd in the enum (as OsString)
+    /// Returns **Command**
+    pub fn parse_cd(cmd: Option<&str>) -> Self {
+        match cmd {
+            None => Command::Cd(None),
+            Some(dest) => Command::Cd(Some(OsString::from(dest))),
+        }
+    }
+
+    /// If this instance is of Kind **Command::Cd** either go to HOME or navigate to the given path
+    pub fn exec_cd(&self) {
+        if let Command::Cd(None) = *self {
+            let possible_home = env::home_dir();
+
+            if let Some(home) = possible_home {
+                let home_path = home.as_path();
+                let _ = env::set_current_dir(home_path);
+            }
+
+        }
+
+        if let Command::Cd(Some(ref path)) = *self {
+            match path.to_str() {
+                Some(_) => {
+                    let _ = env::set_current_dir(path);
+                }
+                None => {}
+            }
+
+        }
+    }
+}
+pub struct Shell<R: BufRead, W: Write> {
+    pub reader: R,
+    pub writer: W,
+    pub should_exit: bool,
+    pub name: String,
+}
+
+impl<R: BufRead, W: Write> Shell<R, W> {
+    /// Creates a new Shell with a name, input and output.
+    pub fn new(input: R, output: W, name: String) -> Self {
+        Shell {
+            reader: input,
+            writer: output,
+            should_exit: false,
+            name: name,
+        }
+    }
+    /// Initializes the Shell Loop.
+    /// Starts the shell.
+    pub fn start(&mut self) -> Result<(), &str> {
+        self.shell_loop()
+    }
+
+    /// Loops while exit hasn't been called.
+    /// When *prompt()* returns (the user hit enter) a Command is created through the FromStr-Trait.
+    /// If the Command-creation succeeds, run the command.
+    fn shell_loop(&mut self) -> Result<(), &str> {
+        while !self.should_exit {
+            if let Ok(Some(line)) = self.prompt() {
+                let _ = Command::from_str(&line).and_then(|cmd| self.run(cmd));
+            }
+        }
+        Ok(())
+    }
+
+    /// Prints the shell prompt.
+    /// Waits for user input and returns the read line.
+    pub fn prompt(&mut self) -> Result<Option<String>, &str> {
+        match env::current_dir() {
+            Ok(pwd) => {
+                let _ = self.writer.write(
+                    format!("{} {} > ", self.name, pwd.display())
+                        .as_bytes(),
+                );
+                let _ = self.writer.flush();
+
+                let mut line: String = String::new();
+                let read_result = self.reader.read_line(&mut line);
+                match read_result {
+                    Ok(_) => Ok(Some(line)),
+                    Err(_) => Ok(None),
+                }
+            }
+            Err(_) => return Err("Path Error"),
+        }
+    }
+
+    /// Runs a command.
+    /// Currently only `cd` and `exit` are working.
+    fn run(&mut self, command: Command) -> Result<(), CommandNotFoundError> {
+
+        match command {
+            Command::Empty => {}
+            Command::Exit => self.should_exit = true,
+            Command::Cd(_) => {
+                command.exec_cd();
+            }
+        }
+        Ok(())
+    }
+}

hw7/task2/src/main.rs

@@ -0,0 +1,16 @@
+extern crate task2;
+
+use std::process;
+use std::io;
+use task2::Shell;
+
+fn main() {
+    let stdin = io::stdin();
+    let stdout = io::stdout();
+
+    let mut s = Shell::new(stdin.lock(), stdout.lock(), "schell".to_string());
+    match s.start() {
+        Ok(_) => process::exit(0),
+        Err(_) => process::exit(1),
+    }
+}

hw7/task2/src/tests/task2.rs

@@ -0,0 +1,95 @@
+#[cfg(test)]
+mod test {
+    pub use shell::Shell;
+    use command::Command;
+    use command::CommandNotFoundError;
+    use std::str::FromStr;
+    use std::ffi::OsString;
+
+    #[test]
+    fn test_command_empty_whitespace() {
+        assert_eq!(Command::from_str("       ").unwrap(), Command::Empty);
+    }
+
+    #[test]
+    fn test_command_empty_tab() {
+        assert_eq!(Command::from_str("\t").unwrap(), Command::Empty);
+    }
+
+    #[test]
+    fn test_command_cd() {
+        assert_eq!(
+            Command::from_str("cd /home/peter/").unwrap(),
+            Command::Cd(Some(OsString::from("/home/peter/")))
+        );
+    }
+
+    #[test]
+    fn test_command_home() {
+        assert_eq!(Command::from_str("cd").unwrap(), Command::Cd(None));
+    }
+
+    #[test]
+    fn test_command_exit() {
+        assert_eq!(Command::from_str("exit").unwrap(), Command::Exit);
+    }
+
+    #[test]
+    fn test_command_not_found() {
+        assert_eq!(
+            Command::from_str("awdeiu33we").unwrap_err(),
+            CommandNotFoundError
+        );
+    }
+
+    #[test]
+    fn test_prompt_in_memory_with_string() {
+        let input = b"echo";
+        let mut output = Vec::new();
+
+        let mut shell = Shell {
+            reader: &input[..],
+            writer: &mut output,
+            should_exit: false,
+            name: "bsys-shell".to_string(),
+        };
+
+        let output = shell.prompt().unwrap().unwrap();
+
+        assert_eq!("echo", output);
+    }
+
+    #[test]
+    fn test_loop_of_shell_which_wants_to_exit() {
+        let input = b"BlaBla";
+        let mut output = Vec::new();
+
+        let mut shell = Shell {
+            reader: &input[..],
+            writer: &mut output,
+            should_exit: true,
+            name: "bsys-shell".to_string(),
+        };
+
+        let output = shell.start().unwrap();
+
+        assert_eq!((), output);
+    }
+
+    #[test]
+    fn test_loop_with_exit_command() {
+        let input = b"exit";
+        let mut output = Vec::new();
+
+        let mut shell = Shell {
+            reader: &input[..],
+            writer: &mut output,
+            should_exit: false,
+            name: "bsys-shell".to_string(),
+        };
+
+        let output = shell.start().unwrap();
+
+        assert_eq!((), output);
+    }
+}