From 6da4a2089e810ba4295d141917e8767a45e5bf72 Mon Sep 17 00:00:00 2001
From: El-BG-1970 <elouan.gros.fr@gmail.com>
Date: Sat, 30 Apr 2022 13:42:19 +0200
Subject: parser on single command seems to work

---
 src/main.rs   | 58 ++++++++++++++++++++++++++++++----------------------------
 src/parser.rs | 23 ++++++++++++++---------
 2 files changed, 44 insertions(+), 37 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index b202f39..3ebcee5 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -6,8 +6,8 @@ use std::path::Path;
 
 mod parser;
 
-fn substitute_vars(word: &str) -> String {
-	match word {
+fn substitute_vars(word: &String) -> String {
+	match word.as_str() {
 		"~" => env::var("HOME").unwrap(),
 		w if w.chars().nth(0).unwrap() == '~' => w.replace("~", env::var("HOME").unwrap().as_str()),
 		w if w.chars().nth(0).unwrap() == '$' => {
@@ -27,35 +27,37 @@ fn main() -> io::Result<()> {
 		
 		let mut line = String::new();
 		stdin().read_line(&mut line).unwrap();
+		line = String::from(line.trim());
 
-		let tmp = line.trim().split_whitespace()
-			.collect::<Vec<&str>>();
-		let mut parts = tmp.iter()
-			.map(|x| substitute_vars(*x));
-		let command = parts.next().unwrap();
-		
-		match command.as_str() {
-			"exit" => return Ok(()),
-			"cd" => {
-				// change directory
-				let new_dir = parts.peekable().peek()
-					.map_or(env::var("HOME").unwrap(),
-							|x| (*x).clone());
-				let new_wd = Path::new(&new_dir);
-				if let Err(e) = env::set_current_dir(&new_wd) {
-					eprintln!("{}", e);
-				}
-			},
-			command => {
-				let child = Command::new(command)
-					.args(parts)
-					.spawn();
+		let c = parser::command_line(&line).unwrap().1;
 
-				match child {
-					Ok(mut child) => { child.wait()?; },
-					Err(e) => eprintln!("{}", e)
+	//	for (c,l) in command {
+		let mut parts = c.iter().map(substitute_vars);
+			let command = parts.next().unwrap();
+			
+			match command.as_str() {
+				"exit" => return Ok(()),
+				"cd" => {
+					// change directory
+					let new_dir = parts.peekable().peek()
+						.map_or(env::var("HOME").unwrap(),
+								|x| (*x).clone());
+					let new_wd = Path::new(&new_dir);
+					if let Err(e) = env::set_current_dir(&new_wd) {
+						eprintln!("{}", e);
+					}
+				},
+				command => {
+					let child = Command::new(command)
+						.args(parts)
+						.spawn();
+
+					match child {
+						Ok(mut child) => { child.wait()?; },
+						Err(e) => eprintln!("{}", e)
+					}
 				}
-			}
+	//		}
 		}
 	}
 }
diff --git a/src/parser.rs b/src/parser.rs
index b95e619..b43d16e 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -1,14 +1,16 @@
 use nom::{
 	IResult,
 	character::complete::alphanumeric0,
-	character::complete::alphanumeric1,	
+	//character::complete::alphanumeric1,	
 	character::complete::anychar,
+	character::complete::space1,
+	character::complete::space0,
 	bytes::complete::tag,
 	multi::many1,
 	multi::many0,
 	//branch::alt,
 	//combinator::opt,
-	sequence::tuple
+	sequence::tuple,
 };
 
 fn command(i: &str) -> IResult<&str, String> {
@@ -21,29 +23,32 @@ fn command(i: &str) -> IResult<&str, String> {
 	}
 }
 
-fn parameter(i: &str) -> IResult<&str, &str> {
-	alphanumeric1(i)
+fn parameter(i: &str) -> IResult<&str, String> {
+	match tuple((space1, many1(anychar)))(i) {
+		Ok((rest, (_,param))) => Ok((rest, param.iter().collect::<String>())),
+		Err(e) => Err(e)
+	}
 }
 
 fn ligature(i: &str) -> IResult<&str, Option<char>> {
-	match tag(";")(i) {
+	match tuple((space0, tag(";")))(i) {
 		Ok((rest, c)) =>
-			Ok((rest, c.chars().nth(0))),
+			Ok((rest, c.1.chars().nth(0))),
 		Err(e) => Err(e)
 	}
 }
 
-fn command_line(i: &str) -> IResult<&str, Vec<String>> {
+pub fn command_line(i: &str) -> IResult<&str, Vec<String>> {
 	match tuple((command, many0(parameter)))(i) {
 		Ok((rest, (com, params))) => {
 			let mut cmd = vec!(com);
-			params.iter().for_each(|p| cmd.push(String::from(*p)));
+			params.iter().for_each(|p| cmd.push(p.to_string()));
 			Ok((rest, cmd))
 		},
 		Err(e) => Err(e)
 	}
 }
 
-fn command_lines(i: &str) -> IResult<&str, Vec<(Vec<String>,Option<char>)>> {
+pub fn command_lines(i: &str) -> IResult<&str, Vec<(Vec<String>,Option<char>)>> {
 	many1(tuple((command_line, ligature)))(i)
 }
-- 
cgit v1.2.3