support change to previous directory

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "adana"
-version = "0.13.29"
+version = "0.13.30"
 edition = "2021"
 authors = ["Nordine Bittich"]
 license = "MIT"

src/cache_command/mod.rs

@@ -57,7 +57,7 @@ pub enum CacheCommand<'a> {
     Del(&'a str),
     Get(&'a str),
     Exec { key: &'a str, args: Option<&'a str> },
-    Cd { has_tilde: bool, path: Option<&'a str> },
+    Cd(ChangeDirectoryType<'a>),
     Using(&'a str),
     Dump(Option<&'a str>),
     Clear,
@@ -67,6 +67,12 @@ pub enum CacheCommand<'a> {
     PrintAst(&'a str),
     Help,
 }
+#[derive(Debug)]
+pub enum ChangeDirectoryType<'a> {
+    HomeDirectory(Option<&'a str>),
+    Path(&'a str),
+    Previous,
+}
 
 impl CacheCommand<'_> {
     pub const fn doc() -> &'static [(&'static [&'static str], &'static str)] {

src/cache_command/parser.rs

@@ -1,6 +1,6 @@
 use crate::prelude::*;
 
-use super::{constants::*, CacheCommand};
+use super::{constants::*, CacheCommand, ChangeDirectoryType};
 
 fn add_command(command: &str) -> Res<CacheCommand> {
     map(
@@ -131,32 +131,49 @@ fn cd_command(command: &str) -> Res<CacheCommand> {
     map(
         preceded(
             tag_no_case(CD),
-            opt(preceded(
-                multispace1,
-                pair(
-                    map(
-                        opt(preceded(
-                            multispace0,
-                            terminated(tag("~"), opt(tag("/"))),
-                        )),
-                        |h| h.is_some(),
+            alt((
+                map(
+                    verify(rest.map(|r: &str| r.trim()), |s: &str| {
+                        s.is_empty()
+                    }),
+                    |_| ChangeDirectoryType::HomeDirectory(None),
+                ),
+                map(preceded(multispace1, tag("-")), |_| {
+                    ChangeDirectoryType::Previous
+                }),
+                map(
+                    preceded(
+                        multispace1,
+                        pair(
+                            map(
+                                opt(preceded(
+                                    multispace0,
+                                    terminated(tag("~"), opt(tag("/"))),
+                                )),
+                                |h| h.is_some(),
+                            ),
+                            opt(preceded(
+                                multispace0,
+                                verify(
+                                    rest.map(|r: &str| r.trim()),
+                                    |s: &str| !s.is_empty(),
+                                ),
+                            )),
+                        ),
                     ),
-                    opt(preceded(
-                        multispace0,
-                        verify(rest.map(|r: &str| r.trim()), |s: &str| {
-                            !s.is_empty()
-                        }),
-                    )),
+                    |(has_tilde, path)| {
+                        if has_tilde {
+                            ChangeDirectoryType::HomeDirectory(path)
+                        } else if let Some(path) = path {
+                            ChangeDirectoryType::Path(path)
+                        } else {
+                            ChangeDirectoryType::HomeDirectory(None)
+                        }
+                    },
                 ),
             )),
         ),
-        |op| {
-            if let Some((has_tilde, path)) = op {
-                CacheCommand::Cd { has_tilde, path }
-            } else {
-                CacheCommand::Cd { has_tilde: false, path: None }
-            }
-        },
+        CacheCommand::Cd,
     )(command)
 }
 

src/cache_command/process.rs

@@ -22,6 +22,7 @@ pub fn process_command(
     db: &mut impl DbOp<String, String>,
     script_context: &mut BTreeMap<String, RefPrimitive>,
     current_cache: &mut String,
+    previous_dir: &mut PathBuf,
     line: &str,
 ) -> anyhow::Result<()> {
     match parse_command(line) {
@@ -230,20 +231,28 @@ pub fn process_command(
                     );
                 }
             }
-            CacheCommand::Cd { path, has_tilde } => {
-                let path_buf = path
-                    .and_then(|p| {
-                        if has_tilde {
-                            dirs::home_dir().map(|hd| hd.join(p))
-                        } else {
-                            Some(PathBuf::from(p))
+            CacheCommand::Cd(cdt) => {
+                let path_buf = {
+                    match cdt {
+                        super::ChangeDirectoryType::HomeDirectory(path) => {
+                             path.and_then(|p| {
+                                dirs::home_dir().map(|hd| hd.join(p))
+                            })
+                            .or_else(dirs::home_dir)
+                            .context(
+                              "could not change directory. path {path:?} not found!",
+                            )?
+                        }
+                        super::ChangeDirectoryType::Path(path) => {
+                            PathBuf::from(path)
                         }
-                    })
-                    .or_else(dirs::home_dir)
-                    .context(
-                        "could not change directory. path {path:?} not found!",
-                    )?;
+                        super::ChangeDirectoryType::Previous => {
+                            previous_dir.clone()
+                        },
+                    }
+                };
                 if path_buf.exists() {
+                    *previous_dir = std::env::current_dir()?;
                     std::env::set_current_dir(path_buf.as_path())?;
                 } else {
                     return Err(anyhow::Error::msg(format!(

src/main.rs

@@ -88,14 +88,16 @@ fn start_app(
     };
     let mut rl = editor::build_editor(history_path);
     let mut script_context = BTreeMap::new();
+    let mut previous_dir = std::env::current_dir()?;
+
     if let Some(dc) = default_cache {
         process_command(
             db,
             &mut script_context,
             &mut current_cache,
+            &mut previous_dir,
             &format!("use {dc}"),
-        )
-        .unwrap();
+        )?;
     }
     loop {
         let readline = editor::read_line(&mut rl, &current_cache);
@@ -121,6 +123,7 @@ fn start_app(
                             db,
                             &mut script_context,
                             &mut current_cache,
+                            &mut previous_dir,
                             &line,
                         ) {
                             Ok(_) => (),