Documented. Fixed lifetimes.

hw6/task2/src/command.rs

 
 impl Command {
 
+    /// If the passed String exists, set the path of the Cd in the enum
     pub fn parse_cd(cmd: Option<&str>) -> Self {
         match cmd {
             None => Command::Cd(None),

hw6/task2/src/main.rs

 use std::process;
-use shell::Shell;
-use shell::{R, W};
+use shell::{Shell, R, W};
 use std::io;
 
 mod command;

hw6/task2/src/shell.rs

 use std::str::FromStr;
 use std::env;
 
+///Tuple-Structs which hold Std-in and -out locks.
 pub struct R<'a>(pub StdinLock<'a>);
 pub struct W<'a>(pub StdoutLock<'a>);
 
     pub name: String,
 }
 
-impl <R:BufRead, W:Write> Shell<R, W> {
-    /// Creates a new Shell.
-    pub fn new(input: R, output: W, name: String) -> Self {
+impl <'a> Shell<R<'a>, W<'a>> {
+    /// Creates a new Shell with a name, input and output.
+    pub fn new(input: R<'a>, output: W<'a>, name: String) -> Self {
         Shell {
             reader : input,
             writer : output,
             name : name,
         }
     }
-    /// Initializes the Shell Loop
+    /// Initializes the Shell Loop.
+    /// Starts the shell.
     pub fn start(&mut self) -> Result<(), &str> {
         self.shell_loop()
     }
 
-    /// Waits for user inputs.
+    /// 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(line) = self.prompt() {
     }
 
     /// Prints the shell prompt.
+    /// Waits for user input and returns the read line.
     fn prompt (&mut self) -> Result<String, &str> {
-
-
         match env::current_dir() {
             Ok(pwd) => {
                 let _ = self.writer.write(format!("{} {} > ", self.name, pwd.display()).as_bytes());
             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 {
 
 }
 
+/// Implement Read-Trait for Tuple-Struct R
+/// Simply calls `read` of StdinLock
 impl <'a>Read for R<'a> {
     fn read(&mut self, buf: &mut [u8]) -> Result<usize, io::Error> {
         self.0.read(buf)
     }
 }
 
+/// Implement BufRead-Trait for Tuple-Struct R
+/// Simply calls `fill_buff` and `consume` from StdinLock
 impl <'a>BufRead for R<'a> {
-
     fn fill_buf(&mut self) -> Result<&[u8], io::Error> {
         self.0.fill_buf()
     }
     }
 }
 
+/// Implement Write-Trait for Tuple-Struct W
+/// Simply calls `write` and `flush` from StdoutLock
 impl <'a>Write for W<'a> {
     fn write(&mut self, buf: &[u8]) -> Result<usize, io::Error> {
         self.0.write(buf)
     }
-    
+
     fn flush(&mut self) -> Result<(),  io::Error> {
         self.0.flush()
     }