Better history, better prompt

README.md

@@ -22,6 +22,96 @@ Later, I can even make something useful out of it. For example, I could make it
 * Add a function that gets the path of the history file, rather than copying it every time
 * Other tests for the rest of the features
 * Add a builtin history command
-* Add a test for the treat_history_callback function
 * Get some sleep
 * Order the file (modules...)
+
+# Annotated process_line
+```rust
+fn process_line(input: String) -> bool {
+
+    // must be peekable so we know when we are on the last command
+    let mut commands = input.trim().split(" | ").peekable();
+    //Will be used later, in the case of pipes
+    let mut previous_command = None;
+
+    //While have commands to process...
+    while let Some(command) = commands.next()  {
+        //First command is divided...
+        let mut parts = command.trim().split_whitespace();
+        //into a command...
+        let mut command = parts.next().unwrap();
+        //and args
+        let args = parts;
+
+        //builtins : exit and cd are special
+        match command {
+            "cd" => {
+                //If a dir is given, we use it by dereferencing
+                //otherwise it is /
+                let new_dir = args.peekable().peek().map_or("/", |x| *x);
+                let root = Path::new(new_dir);
+                if let Err(e) = env::set_current_dir(&root) {
+                    eprintln!("{}", e);
+                }
+
+                previous_command = None;
+            },
+            "exit" => return true,
+            "history" => {
+                let stdout = Stdio::inherit();
+                println!("Insert history here");
+            },
+            //not builtin: we process it
+            command => {
+                //If we are at the first command (aka previous_command is None)...
+                let stdin = previous_command.map_or(
+                        //We inherit, meaning stdin gets the stream from its parent
+                        //what I guess that means is that the child (our command)
+                        //inherits the file descriptors (stdin, stdout, stderr)
+                        //from the process of this very own rust program !
+                        Stdio::inherit(),
+                        //otherwise, our input is the output from the last command
+                        //(from converts a ChildStdOut to a Stdio)
+                        |output: Child| Stdio::from(output.stdout.unwrap())
+                    );
+
+                let stdout = if commands.peek().is_some() {
+                    // there is another command piped behind this one
+                    // prepare to send output to the next command
+                    Stdio::piped()
+                } else {
+                    // there are no more commands piped behind this one
+                    // send output to shell stdout
+                    // the child inherits from the parent's file descriptor
+                    Stdio::inherit()
+                };
+                
+                //Run the command
+                let output = Command::new(command)
+                    .args(args)
+                    .stdin(stdin)
+                    .stdout(stdout)
+                    //spawn : execute the command as a child process, returning a handle to it
+                    .spawn();
+
+                //Checking for errors
+                //If it matched, previous_command becomes the output of this to be used
+                //next loop
+                match output {
+                    Ok(output) => { previous_command = Some(output); },
+                    Err(e) => {
+                        previous_command = None;
+                        eprintln!("{}", e);
+                    },
+                };
+            }
+        }
+    }
+
+    if let Some(mut final_command) = previous_command {
+        // block until the final command has finished
+        final_command.wait();
+    }
+    return false; 
+}
+```