Almost finished shell. cd working.

Still using unwraps :|

hw6/task2/src/command.rs

@@ -1,20 +1,54 @@
 use std::ffi::OsString;
 use std::str::FromStr;
+use std::env;
+use std::path::Path;
 
-enum Command {
+pub enum Command {
     Empty,
     Exit,
     Cd(Option<OsString>),
 }
 
-impl Command {}
-
-struct CommandNotFoundError();
+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") => return Ok(Command::Exit),
+            Some("cd") => return Ok(Command::parse_cd(parts.next())),
+            Some(_) => return Ok(Command::Empty),
+            None => return Err(CommandNotFoundError),
+        }
+    }
+
+}
+
+impl Command {
+    pub fn parse_cd(cmd: Option<&str>) -> Self {
+        match cmd {
+            None => Command::Cd(None),
+            Some(dest) => Command::Cd(Some(OsString::from(dest))),
+        }
+    }
+
+    pub fn exec_cd(&self) {
+        if let Command::Cd(None) = *self  {
+            let home = env::home_dir().unwrap();
+            let home_path = home.as_path();
+            env::set_current_dir(home_path);
+        }
+
+        if let Command::Cd(Some(ref path)) = *self {
+            match path.to_str() {
+                Some(_) => {env::set_current_dir(path);},
+                None => {},
+            }
+
+        }
     }
 }

hw6/task2/src/main.rs

@@ -1,13 +1,17 @@
 use std::process;
 use shell::Shell;
+use std::io;
 
-mod shell;
 mod command;
+mod shell;
+
 
 fn main() {
-    let reader = shell::R;
-    let writer = shell::W;
-    let mut s = Shell::new(reader, writer, "schell".to_string());
+    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),

hw6/task2/src/shell.rs

@@ -1,20 +1,17 @@
-use std::io;
-use std::io::prelude::*;
 use std::io::BufRead;
-use std::io::Read;
+use std::io::Write;
+use command::*;
+use std::str::FromStr;
+use std::env;
 
-
-pub struct R;
-pub struct W;
-
-pub struct Shell<R, W> {
+pub struct Shell<R:BufRead, W:Write> {
     pub reader: R,
     pub writer: W,
     pub should_exit: bool,
     pub name: String,
 }
 
-impl Shell<R, W> {
+impl <R:BufRead, W:Write> Shell<R, W> {
     /// Creates a new Shell.
     pub fn new(input: R, output: W, name: String) -> Self {
         Shell {
@@ -25,65 +22,58 @@ impl Shell<R, W> {
         }
     }
     /// Initializes the Shell Loop
-    pub fn start<'a>(&self) -> Result<(), &'a str> {
-        self.shell_loop();
-        Ok(())
+    pub fn start(&mut self) -> Result<(), &str> {
+        self.shell_loop()
     }
 
     /// Waits for user inputs.
-    fn shell_loop(&self) -> Result<(),()> {
-        loop {
+    fn shell_loop(&mut self) -> Result<(),&str> {
+        while !self.should_exit {
+            if let Ok(line) = self.prompt() {
+                Command::from_str(&line).and_then(|cmd| self.run(cmd));
+            }
         }
+        Ok(())
     }
 
-    /*
     /// Prints the shell prompt.
-    fn prompt() -> Result<Option, &str> {
+    fn prompt (&mut self) -> Result<String, &str> {
+
+
+        match env::current_dir() {
+            Ok(pwd) => {
+                self.writer.write(format!("{} {} > ", self.name, pwd.display()).as_bytes());
+                self.writer.flush();
+
+                let mut line: String = String::new();
+                let read_result = self.reader.read_line(&mut line);
+                match read_result {
+                    Ok(_) => {
+                        Ok(line)
+                    },
+                    Err(_) => {
+                        Err("Error reading.")
+                    },
+                }
+            },
+            Err(_) => return Err("Path Error"),
+        }
     }
     /// Runs a command.
-    fn run(&str) {
-    }
-
-    */
-}
-
-
-impl Read for R {
-    fn read(&mut self, buf: &mut [u8]) -> Result<usize, io::Error> {
-        let stdin = io::stdin();
-        let mut stdin = stdin.lock();
-
-
-        let buffer = stdin.read(buf);
-
-        match buffer {
-            Ok(x) => {
-                println!("{} ||| {:?}", x, buffer);
-                stdin.consume(x);
-                Ok(x)
+    fn run(&mut self, command: Command) -> Result<(), CommandNotFoundError>{
+
+        match command {
+            Command::Empty => {
+                self.writer.write("Command not found\n".as_bytes());
+                self.writer.flush();
+                return Err(CommandNotFoundError);},
+            Command::Exit => self.should_exit = true,
+            Command::Cd(_) => {
+                command.exec_cd();
             },
-            Err(_) => Err(io::Error::new(io::ErrorKind::InvalidInput, "jhrthhzruzkikz")),
         }
-    }
-}
-
-impl BufRead for R {
-
-    fn fill_buf(&mut self) -> Result<&[u8], io::Error> {
-        Ok(&[11])
+        Ok(())
     }
 
-    fn consume(&mut self, amt: usize) {
-        let mut buffer = self.fill_buf;
-        if buffer.len <= amt {
-
-        }
-    }
 }
 
-impl Write for W {
-    fn write(&mut self, buf: &[u8]) -> Result<usize, io::Error> {
-    }
-    fn flush(&mut self) -> Result<(),  io::Error> {
-    }
-}