refactor: enhance directory handling and update CLI options for improved functionality

Author: tamada

cli/src/cli.rs

@@ -65,8 +65,8 @@ pub(crate) struct NexterOpts {
     )]
     pub input: Option<String>,
 
-    #[arg(short = 'S', long, help = "strictly check the directory traversing", default_value_t = false)]
-    pub strict: bool,
+    #[arg(short = 'a', long, help = "Set the targets to all directories from the given list. By default, the sibling skips non-existent directories.", default_value_t = false)]
+    pub all: bool,
 }
 
 #[cfg(debug_assertions)]
@@ -108,7 +108,7 @@ pub(crate) struct PrintingOpts {
     pub format: Format,
 
     #[arg(
-        short,
+        short = 'A',
         long,
         help = "print the directory name in the absolute path",
         default_value_t = false

cli/src/main.rs

@@ -7,7 +7,7 @@ use sibling::{Dirs, Error, Nexter, Result};
 mod cli;
 mod gencomp;
 mod init;
-mod printer;
+pub(crate) mod printer;
 pub(crate) mod minisib;
 
 #[derive(clap::ValueEnum, Clone, Debug)]
@@ -50,7 +50,7 @@ fn perform_from_file(opts: CliOpts) -> Vec<Result<String>> {
     let nexter = sibling::NexterFactory::create(opts.nexter_opts.nexter);
     let r = match opts.nexter_opts.input {
         None => Err(Error::Fatal("input is not specified".into())),
-        Some(file) => match Dirs::new_from_file(file) {
+        Some(file) => match Dirs::new_from_file_with(file, opts.nexter_opts.all) {
             Err(e) => Err(e),
             Ok(dirs) => Ok(perform_impl(&dirs, nexter.as_ref(), opts.nexter_opts.step, &opts.p_opts)),
         },

cli/src/minisib.rs

@@ -91,12 +91,16 @@ impl MiniSibOpts {
         };
         if let Some(dir) = target_dirs.next_with(nexter.as_ref(), self.step) {
             Ok(format!("{}\n{}\n{}\n{}",
-                dir.path().to_string_lossy(),
+                crate::printer::pathbuf_to_string(Some(dir.path()), false, target_dirs.on_dirs),
                 target_dirs.len(),
                 dir.index(),
                 dir.is_last_item()))
         } else {
-            Err(Error::Fatal("No sibling directory found".into()))
+            Ok(format!("{}\n{}\n{}\n{}",
+                crate::printer::pathbuf_to_string(Some(target_dirs.parent()), false, target_dirs.on_dirs),
+                target_dirs.len(),
+                -1,
+                true))
         }
 
     }

cli/src/printer.rs

@@ -24,10 +24,10 @@ pub(crate) fn result_string(
 
 fn json_string(dirs: &Dirs, next: Option<Dir<'_>>, absolute: bool) -> String {
     let current = dirs.current();
-    let next_path = next.as_ref().map(|n| pathbuf_to_string(Some(n.path()), absolute));
+    let next_path = next.as_ref().map(|n| pathbuf_to_string(Some(n.path()), absolute, dirs.on_dirs));
     format!(
         r#"{{"current":{{"path":"{}","index":{}}},"next":{{"path":"{}","index":{}}},"total":{}}}"#,
-        pathbuf_to_string(Some(dirs.current().path()), absolute),
+        pathbuf_to_string(Some(dirs.current().path()), absolute, dirs.on_dirs),
         current.index() + 1,
         next_path.unwrap_or_default(),
         next.map_or(-1, |n| i32::try_from(n.index()).unwrap() + 1),
@@ -39,8 +39,8 @@ fn csv_string(dirs: &Dirs, next: Option<Dir<'_>>, absolute: bool) -> String {
     let current = dirs.current();
     format!(
         r#""{}","{}",{},{},{}"#,
-        pathbuf_to_string(Some(dirs.current().path()), absolute),
-        pathbuf_to_string(next.as_ref().map(Dir::path), absolute),
+        pathbuf_to_string(Some(dirs.current().path()), absolute, dirs.on_dirs),
+        pathbuf_to_string(next.as_ref().map(Dir::path), absolute, dirs.on_dirs),
         current.index() + 1,
         next.map_or(-1, |n| i32::try_from(n.index()).unwrap() + 1),
         dirs.len()
@@ -49,7 +49,7 @@ fn csv_string(dirs: &Dirs, next: Option<Dir<'_>>, absolute: bool) -> String {
 
 fn no_more_dir_string(dirs: &Dirs, opts: &PrintingOpts) -> String {
     if opts.parent {
-        pathbuf_to_string(Some(dirs.parent()), opts.absolute)
+        pathbuf_to_string(Some(dirs.parent()), opts.absolute, dirs.on_dirs)
     } else {
         String::from("no more sibling directory")
     }
@@ -71,7 +71,7 @@ fn list_string(dirs: &Dirs, next: Option<&Dir<'_>>, opts: &PrintingOpts) -> Stri
             "{:>4} {}{}",
             i + 1,
             prefix,
-            pathbuf_to_string(Some(dir), opts.absolute)
+            pathbuf_to_string(Some(dir), opts.absolute, dirs.on_dirs)
         ));
     }
     result.join("\n")
@@ -81,16 +81,16 @@ fn result_string_impl(dirs: &Dirs, next: Option<Dir<'_>>, opts: &PrintingOpts) -
     if opts.progress {
         format!(
             "{} ({}/{})",
-            pathbuf_to_string(next.as_ref().map(Dir::path), opts.absolute),
+            pathbuf_to_string(next.as_ref().map(Dir::path), opts.absolute, dirs.on_dirs),
             next.map_or(-1, |n| i32::try_from(n.index()).unwrap()) + 1,
             dirs.len()
         )
     } else {
-        pathbuf_to_string(next.as_ref().map(Dir::path), opts.absolute).to_string()
+        pathbuf_to_string(next.as_ref().map(Dir::path), opts.absolute, dirs.on_dirs).to_string()
     }
 }
 
-fn pathbuf_to_string(path: Option<&Path>, absolute: bool) -> String {
+pub(crate) fn pathbuf_to_string(path: Option<&Path>, absolute: bool, on_dirs: bool) -> String {
     match path {
         Some(p) => {
             if absolute {
@@ -99,7 +99,11 @@ fn pathbuf_to_string(path: Option<&Path>, absolute: bool) -> String {
                     .to_string_lossy()
                     .to_string()
             } else {
-                p.to_string_lossy().to_string()
+                if on_dirs && !p.is_absolute() {
+                    format!("../{}", p.to_string_lossy())
+                } else {
+                    p.to_string_lossy().to_string()
+                }
             }
         }
         None => String::new(),

lib/Cargo.toml

@@ -16,3 +16,6 @@ rand = "0.10.0"
 rust-embed = "8.5.0"
 clap = { version = "4.5.23", features = ["derive"] }
 log = "0.4.29"
+
+[dev-dependencies]
+env_logger = "0.11.8"

lib/src/lib.rs

@@ -104,6 +104,8 @@ pub struct Dirs {
     entries: Vec<PathBuf>,
     /// The parent directory that contains all the sibling directories.
     parent: PathBuf,
+    /// Flag indicating whether the current directory is among the sibling directories.
+    pub on_dirs: bool,
     /// The index of the current directory in the `dirs` vector.
     current: usize,
 }
@@ -167,7 +169,7 @@ impl Dirs {
     ///
     /// # Returns
     ///
-    /// A [`Result`]<[`Dirs`]> instance.
+    /// A [`Result`]<[`Dirs`], [`Error`]> instance.
     ///
     /// # Errors
     ///
@@ -202,34 +204,41 @@ impl Dirs {
     /// Create a new [`Dirs`] instance from the given file.
     /// The file should contain a list of directories, one per line.
     /// The first line can optionally specify the parent directory in the format `parent:/path/to`.
+    /// If the current directory is not found in the list, the current index is set to 0.
+    /// If `all_target` parameter is false, non-existent directories are skipped and
+    /// the resultant list does not include them.
     ///
     /// # Returns
-    /// A [`Result`]<[`Dirs`]> instance.
+    /// A [`Result`]<[`Dirs`], [`Error`]> instance.
     ///
     /// # Errors
     ///
     /// - Returns [`Error::Io`] if an I/O error occurs.
     /// - Returns [`Error::NotFile`] if the given path is not a file.
     /// - Returns [`Error::NotFound`] if the given path does not exist.
-    pub fn new_from_file<S: AsRef<str>>(file: S) -> Result<Self> {
+    pub fn new_from_file_with<S: AsRef<str>>(file: S, all_target: bool) -> Result<Self> {
         log::debug!("Dirs::new_from_file(file={})", file.as_ref());
         let file = file.as_ref();
         if file == "-" {
             log::info!("Reading directories from stdin");
-            return Ok(build_from_reader(Box::new(std::io::stdin().lock())));
+            return Ok(build_from_reader(Box::new(std::io::stdin().lock()), all_target));
         }
         let path = PathBuf::from(file);
         if !path.exists() {
-            log::error!("Dirs::new_from_file: Not found: {}", path.display());
+            log::error!("Dirs::new_from_file: Not found: {}, pwd: {}", path.display(), std::env::current_dir().unwrap().display());
             Err(Error::NotFound(path))
         } else if path.is_dir() {
             log::error!("Dirs::new_from_file: Not a file: {}", path.display());
             Err(Error::NotFile(path))
         } else {
-            build_from_list(&path)
+            build_from_list(&path, all_target)
         }
     }
 
+    pub fn new_from_file<S: AsRef<str>>(file: S) -> Result<Self> {
+        Dirs::new_from_file_with(file, false)
+    }
+
     /// Get the parent directory path.
     #[must_use]
     pub fn parent(&self) -> &Path {
@@ -281,20 +290,12 @@ fn build_dirs(parent: Option<&Path>, current: PathBuf) -> Result<Dirs> {
     let mut errs = vec![];
     let dirs = collect_dirs(parent, &mut errs);
     if errs.is_empty() {
-        let current_index = find_current(&dirs, &current);
-        let index = if current_index == -1 {
-            log::warn!(
-                "build_dirs: current directory not found in siblings: {}",
-                current.display()
-            );
-            0
-        } else {
-            usize::try_from(current_index).unwrap()
-        };
+        let (index, on_dirs) = find_current(&dirs, &current);
         log::info!("build_dirs: siblings={}, current_index={index}", dirs.len());
         Ok(Dirs {
             entries: dirs,
             parent: parent.to_path_buf(),
+            on_dirs: on_dirs,
             current: index,
         })
     } else {
@@ -330,61 +331,77 @@ fn collect_dirs(parent: &Path, errs: &mut Vec<Error>) -> Vec<PathBuf> {
 }
 
 /// Return the index of current in dirs, or 0 if not found.
-fn find_current(dirs: &[PathBuf], current: &PathBuf) -> i32 {
+fn find_current(dirs: &[PathBuf], current: &PathBuf) -> (usize, bool) {
     let idx = dirs
         .iter()
-        .position(|dir| dir == current)
-        .map_or(-1, |i| i32::try_from(i).unwrap());
-    log::trace!("find_current: index={} for {}", idx, current.display());
-    idx
+        .position(|dir| dir == current);
+    if let Some(index) = idx {
+        log::trace!("find_current: found current at index {index}");
+        (index, true)
+    } else {
+        log::warn!("find_current: current directory not found in siblings");
+        (0, false)
+    }
 }
 
 /// Parse lines from a reader; parent: sets base, remaining lines are directory entries.
-fn build_from_reader(reader: Box<dyn BufRead>) -> Dirs {
-    let lines = reader
-        .lines()
-        .filter_map(|line| line.map(|n| n.trim().to_string()).ok())
-        .collect::<Vec<String>>();
-    let base = if let Some(base) = lines.iter().find(|l| l.starts_with("parent:")) {
-        base.chars().skip(7).collect::<String>().trim().to_string()
-    } else {
-        ".".to_string()
-    };
-    let dirs = lines
-        .iter()
-        .filter(|l| !l.starts_with("parent:"))
-        .map(PathBuf::from)
-        .collect::<Vec<PathBuf>>();
-    log::debug!("build_from_reader: base='{}', entries={}", base, dirs.len());
-    let current = find_current_dir_index(&dirs);
-    if current == 0 {
-        log::warn!("build_from_reader: current directory not found in siblings");
+fn build_from_reader(reader: Box<dyn BufRead>, all_target: bool) -> Dirs {
+    let mut parent = String::from(".");
+    let mut lines = vec![];
+    for line in reader.lines() {
+        if let Ok(line) = line {
+            if line.starts_with("parent:") {
+                parent = line.chars().skip("parent:".len()).collect::<String>().trim().to_string();
+            } else {
+                let p = Path::new(line.trim());
+                if !all_target && not_exists(p) {
+                    continue;
+                } else {
+                    lines.push(p.to_path_buf());
+                }
+            }
+        }
+    }
+    log::debug!("build_from_reader: base='{}', entries={}", parent, lines.len());
+    let (current, on_dirs) = find_current_dir_index(&lines);
+    if !on_dirs {
+        log::debug!("build_from_reader: current directory not found in siblings");
     }
     Dirs {
-        entries: dirs,
-        parent: PathBuf::from(base),
+        entries: lines,
+        parent: PathBuf::from(parent),
+        on_dirs,
         current,
     }
 }
 
-fn find_current_dir_index(dirs: &[PathBuf]) -> usize {
+fn not_exists(path: &Path) -> bool {
+    if path.exists() {
+        false
+    } else {
+        let sibling_p = Path::new("..").join(path);
+        !sibling_p.exists()
+    }
+}
+
+fn find_current_dir_index(dirs: &[PathBuf]) -> (usize, bool) {
     log::trace!("find_current_dir_index(dirs.len={})", dirs.len());
     if let Ok(pwd) = std::env::current_dir() {
         let cwd = PathBuf::from(".");
         if let Some(pos) = dirs
             .iter()
             .position(|dir| dir == &cwd || pwd.ends_with(dir))
         {
-            return pos;
+            return (pos, true);
         }
     }
-    0
+    (0, false)
 }
 
-fn build_from_list(filename: &Path) -> Result<Dirs> {
+fn build_from_list(filename: &Path, all_target: bool) -> Result<Dirs> {
     if let Ok(f) = std::fs::File::open(filename) {
         let reader = BufReader::new(f);
-        Ok(build_from_reader(Box::new(reader)))
+        Ok(build_from_reader(Box::new(reader), all_target))
     } else {
         log::error!("build_from_list: I/O error: {}", filename.display());
         Err(Error::Io(std::io::Error::last_os_error()))
@@ -548,7 +565,7 @@ mod tests {
         let dirs = dirs.unwrap();
         assert_eq!(dirs.len(), 4);
         assert_eq!(dirs.current, 1);
-        assert_eq!(dirs.parent, PathBuf::from("testdata/basic"));
+        assert_eq!(dirs.parent, PathBuf::from("../testdata/basic"));
     }
 
     #[test]

lib/tests/common/mod.rs

@@ -0,0 +1,8 @@
+pub(super) fn init() {
+    if std::env::var_os("RUST_LOG").is_none() {
+        unsafe {
+            std::env::set_var("RUST_LOG", "debug");
+        }
+    }
+    let _ = env_logger::builder().is_test(true).try_init();
+}

lib/tests/skip_non_existent_dir.rs

@@ -0,0 +1,31 @@
+use std::path::Path;
+
+mod common;
+
+#[test]
+pub fn test_skip_non_existent_dir() {
+    common::init();
+    let _ = std::env::set_current_dir(Path::new("../testdata/basic"));
+    let dirs = sibling::Dirs::new_from_file("../skip.txt")
+        .expect("Failed to create Dirs from skip.txt");
+    assert_eq!(dirs.len(), 2);
+
+    let dir = dirs.next(
+        sibling::NexterFactory::create(sibling::NexterType::Next).as_ref(),
+    ).expect("Failed to get next directory");
+    assert_eq!(dir.path().to_string_lossy(), "worried");
+}
+
+#[test]
+pub fn test_skip_non_existent_dir2() {
+    common::init();
+    let _ = std::env::set_current_dir(Path::new("../testdata/basic"));
+    let dirs = sibling::Dirs::new_from_file_with("../skip.txt", true)
+        .expect("Failed to create Dirs from skip.txt");
+    assert_eq!(dirs.len(), 4);
+
+    let dir = dirs.next(
+        sibling::NexterFactory::create(sibling::NexterType::Previous).as_ref(),
+    ).expect("Failed to get next directory");
+    assert_eq!(dir.path().to_string_lossy(), "unknown_dir");
+}

testdata/basic/dirlist.txt

@@ -1,5 +1,5 @@
-testdata/basic/a
+../testdata/basic/a
 .
-testdata/basic/b
-testdata/basic/c
-parent:testdata/basic
+../testdata/basic/b
+../testdata/basic/c
+parent:../testdata/basic

testdata/demo/.init_demo.sh

@@ -0,0 +1,2 @@
+LC_ALL=C tr -dc 'A-Za-z0-9' < /dev/urandom | fold -w 8 | head -n 100 | xargs mkdir
+\ls | shuf | head -5 > target.txt