From 3ed823485252f62a2ce832262dedfb1e81d32efb Mon Sep 17 00:00:00 2001
From: Jan Klattenhoff <jan@kjan.de>
Date: Wed, 28 Aug 2024 12:17:44 +0200
Subject: [PATCH 1/2] feat: add support for 'cd' command in REPL loop

---
 src/main.rs | 28 ++++++++++++++++++----------
 1 file changed, 18 insertions(+), 10 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index d43b637..46a2036 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,9 +1,7 @@
-use std::{io::{stdin, stdout, Write}, process::Command};
+use std::{env, io::{stdin, stdout, Write}, path::Path, process::Command};
 
 fn main(){
     loop {
-        // use the `>` character as the prompt
-        // need to explicitly flush this to ensure it prints before read_line
         print!("> ");
         stdout().flush();
 
@@ -14,13 +12,23 @@ fn main(){
         let command = parts.next().unwrap();
         let args = parts;
 
-        let mut child = Command::new(command)
-            .args(args)
-            .spawn()
-            .unwrap();
+        match command {
+            "cd" => {
+                // default to '/' as new directory if one was not provided
+                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);
+                }
+            },
+            command => {
+                let mut child = Command::new(command)
+                    .args(args)
+                    .spawn()
+                    .unwrap();
 
-        // don't accept another command until this one completes
-        child.wait(); 
+                child.wait();
+            }
+        }
     }
 }
-

From 797f401cf302508026aeb6fb8bdd1a0ed3fd5be8 Mon Sep 17 00:00:00 2001
From: Jan Klattenhoff <jan@kjan.de>
Date: Wed, 28 Aug 2024 12:31:16 +0200
Subject: [PATCH 2/2] feat: implement command piping in shell program

---
 src/main.rs | 77 ++++++++++++++++++++++++++++++++++++++++-------------
 1 file changed, 58 insertions(+), 19 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index 46a2036..6085b11 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,4 +1,4 @@
-use std::{env, io::{stdin, stdout, Write}, path::Path, process::Command};
+use std::{env, io::{stdin, stdout, Write}, path::Path, process::{Child, Command, Stdio}};
 
 fn main(){
     loop {
@@ -8,27 +8,66 @@ fn main(){
         let mut input = String::new();
         stdin().read_line(&mut input).unwrap();
 
-        let mut parts = input.trim().split_whitespace();
-        let command = parts.next().unwrap();
-        let args = parts;
+        // must be peekable so we know when we are on the last command
+        let mut commands = input.trim().split(" | ").peekable();
+        let mut previous_command = None;
 
-        match command {
-            "cd" => {
-                // default to '/' as new directory if one was not provided
-                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);
+        while let Some(command) = commands.next()  {
+
+            let mut parts = command.trim().split_whitespace();
+            let command = parts.next().unwrap();
+            let args = parts;
+
+            match command {
+                "cd" => {
+                    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,
+                command => {
+                    let stdin = previous_command
+                        .map_or(
+                            Stdio::inherit(),
+                            |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
+                        Stdio::inherit()
+                    };
+
+                    let output = Command::new(command)
+                        .args(args)
+                        .stdin(stdin)
+                        .stdout(stdout)
+                        .spawn();
+
+                    match output {
+                        Ok(output) => { previous_command = Some(output); },
+                        Err(e) => {
+                            previous_command = None;
+                            eprintln!("{}", e);
+                        },
+                    };
                 }
-            },
-            command => {
-                let mut child = Command::new(command)
-                    .args(args)
-                    .spawn()
-                    .unwrap();
-
-                child.wait();
             }
         }
+
+        if let Some(mut final_command) = previous_command {
+            // block until the final command has finished
+            final_command.wait();
+        }
+
     }
 }