feat: no longer needs /** for dir

Signed-off-by: lxl66566 <lxl66566@gmail.com>

Author: lxl66566

Cargo.lock

@@ -9,7 +9,7 @@ license     = "MIT"
 name        = "git-simple-encrypt"
 readme      = "./README.md"
 repository  = "https://github.com/lxl66566/git-simple-encrypt"
-version     = "2.0.0"
+version     = "1.5.0"
 
 [dependencies]
 aes-gcm-siv       = "0.11.1"
@@ -22,7 +22,7 @@ const-str         = "0.6.2"
 copy-metadata     = "0.1.0"
 die-exit          = { version = "0.5.0", features = ["red"] }
 enum-tools        = "0.5.5"
-glob              = "0.3.2"
+fuck-backslash    = "0.1.0"
 log               = "0.4"
 num_cpus          = "1.16.0"
 path-absolutize   = "3.1.1"
@@ -32,6 +32,7 @@ rayon             = "1.10.0"
 serde             = { version = "1.0.219", features = ["derive"] }
 sha3              = "0.10.8"
 tap               = "1.0.1"
+walkdir           = "2.5.0"
 zstd              = "0.13.3"
 
 [target.'cfg(target_arch = "aarch64")'.dependencies]

Cargo.toml

@@ -54,12 +54,12 @@ pub enum SubCommand {
     #[clap(alias("d"))]
     Decrypt {
         /// The files or folders to be decrypted, use wildcard matches.
-        path: Option<String>,
+        path: Option<PathBuf>,
     },
     /// Mark files or folders as need-to-be-crypted.
     Add {
         #[clap(required = true)]
-        paths: Vec<String>,
+        paths: Vec<PathBuf>,
     },
     /// Set key or other config items.
     Set {

src/cli.rs

@@ -4,9 +4,10 @@ use assert2::assert;
 use colored::Colorize;
 use config_file2::StoreConfigFile;
 use log::{debug, info, warn};
-use path_absolutize::Absolutize;
+use path_absolutize::Absolutize as _;
 use pathdiff::diff_paths;
 use serde::{Deserialize, Serialize};
+use walkdir::WalkDir;
 
 use crate::{
     crypt::{COMPRESSED_EXTENSION, ENCRYPTED_EXTENSION},
@@ -41,12 +42,15 @@ impl Default for Config {
 }
 
 impl Config {
-    pub fn new(path: impl Into<PathBuf>) -> Self {
-        let path = path.into();
+    pub fn new(path: impl AsRef<Path>) -> Self {
         Self::default().with_repo_path(path)
     }
-    pub fn with_repo_path(mut self, path: impl Into<PathBuf>) -> Self {
-        self.repo_path = path.into();
+    pub fn with_repo_path(mut self, path: impl AsRef<Path>) -> Self {
+        self.repo_path = path
+            .as_ref()
+            .absolutize()
+            .expect("path absolutize failed")
+            .to_path_buf();
         self
     }
     /// The absolute path of the config file.
@@ -56,11 +60,9 @@ impl Config {
     /// Add one path to crypt list
     ///
     /// path: relative path to a file or dir.
-    pub fn add_one_file_to_crypt_list(&mut self, path: &str) {
+    pub fn add_one_file_to_crypt_list(&mut self, path: impl AsRef<Path>) {
         // path is the relative path to the current dir (or absolute path)
-        let path = Path::new(path)
-            .absolutize()
-            .expect("path absolutize failed");
+        let path = path.as_ref().absolutize().expect("path absolutize failed");
 
         debug!("add_one_file_to_crypt_list: {}", path.display());
         assert!(
@@ -96,37 +98,35 @@ impl Config {
             "Add to crypt list: {}",
             format!("{}", path_relative_to_repo.display()).green()
         );
-        self.crypt_list.push(
-            path_relative_to_repo.to_string_lossy().replace('\\', "/")
-                + if path.is_dir() { "/**" } else { "" },
-        );
+        self.crypt_list
+            .push(path_relative_to_repo.to_string_lossy().replace('\\', "/"));
 
         // check extension
         if path.is_dir() {
-            if let Ok(glob_result) = glob::glob(path.join("**").to_string_lossy().as_ref()) {
-                glob_result
-                    .filter_map(std::result::Result::ok)
-                    .for_each(|p| {
-                        if let Some(ext) = p.extension().and_then(|ext| ext.to_str())
-                            && [COMPRESSED_EXTENSION, ENCRYPTED_EXTENSION].contains(&ext)
-                        {
-                            warn!(
-                                "{}",
-                                format!(
-                                    "adding dir that contains file with no-good extension: {}",
-                                    p.display()
-                                )
-                                .yellow()
-                            );
-                        }
-                    });
+            for entry in WalkDir::new(path)
+                .into_iter()
+                .filter_map(std::result::Result::ok)
+            {
+                if let Some(ext) = entry.path().extension().and_then(|ext| ext.to_str())
+                    && [COMPRESSED_EXTENSION, ENCRYPTED_EXTENSION].contains(&ext)
+                {
+                    warn!(
+                        "{}",
+                        format!(
+                            "adding dir that contains file with no-good extension: {}",
+                            entry.path().display()
+                        )
+                        .yellow()
+                    );
+                }
             }
         }
     }
-    pub fn add_to_crypt_list(&mut self, paths: &[&str]) -> anyhow::Result<()> {
+
+    pub fn add_to_crypt_list(&mut self, paths: &[impl AsRef<Path>]) -> anyhow::Result<()> {
         paths
             .iter()
-            .for_each(|x| self.add_one_file_to_crypt_list(x));
+            .for_each(|x| self.add_one_file_to_crypt_list(x.as_ref()));
         self.store(CONFIG_FILE_NAME).map_err(|e| anyhow::anyhow!(e))
     }
 }
@@ -170,11 +170,14 @@ mod tests {
         let path_to_add = temp_dir.join("testdir");
         fs::create_dir(&path_to_add)?;
         config.add_one_file_to_crypt_list(path_to_add.as_os_str().to_string_lossy().as_ref());
-        println!("{:?}", config.crypt_list.first());
+        println!("{:?}", config.crypt_list.first().unwrap());
         assert!(
-            config.crypt_list[0].ends_with("/**"),
-            "needs to be dir pattern: `{}`",
-            config.crypt_list[0]
+            config
+                .repo_path
+                .join(config.crypt_list.first().unwrap())
+                .is_dir(),
+            "needs to be dir: {}",
+            config.crypt_list.first().unwrap()
         );
         Ok(())
     }

src/config.rs

@@ -11,8 +11,7 @@ use aes_gcm_siv::{
 use anyhow::{Context, Result, anyhow};
 use colored::Colorize;
 use copy_metadata::copy_metadata;
-use die_exit::{DieWith, die};
-use glob::Pattern;
+use die_exit::die;
 use log::{debug, info};
 use rayon::{iter::IntoParallelRefIterator, prelude::*};
 use sha3::{Digest, Sha3_224};
@@ -24,7 +23,7 @@ extern crate test;
 use crate::utils::format_hex;
 use crate::{
     repo::{GitCommand, Repo},
-    utils::pathutils::{Git2Patch, PathAppendExt},
+    utils::pathutils::PathAppendExt,
 };
 
 static NONCE: Lazy<&Nonce> = Lazy::new(|| Nonce::from_slice(b"samenonceplz"));
@@ -220,39 +219,28 @@ pub fn encrypt_repo(repo: &'static Repo) -> anyhow::Result<()> {
     Ok(())
 }
 
-pub fn decrypt_repo(repo: &'static Repo, path: Option<&String>) -> anyhow::Result<()> {
+pub fn decrypt_repo(repo: &'static Repo, path: Option<impl AsRef<Path>>) -> anyhow::Result<()> {
     assert!(!repo.get_key().is_empty(), "Key must not be empty");
-    let dot_pattern = String::from("*.") + ENCRYPTED_EXTENSION;
-
-    // partial decrypt filter
-    let pattern: Option<Pattern> = path.as_ref().map(|x| {
-        glob::Pattern::new(
-            repo.path
-                .join(Path::new(x.as_str()).patch())
-                .to_string_lossy()
-                .as_ref()
-                .tap(|x| println!("Decrypting with pattern: {}", x.green())),
-        )
-        .die_with(|e| format!("Invalid pattern: {e}"))
-    });
 
-    let decrypt_futures = repo
-        .ls_files_absolute_with_given_patterns(&[dot_pattern.as_str()])?
+    let pattern = if let Some(path) = path {
+        let path = path.as_ref();
+        if path.is_dir() {
+            format!("{}/*.{ENCRYPTED_EXTENSION}", path.to_path_buf().display(),)
+        } else {
+            decrypt_file(path, repo.get_key_sha())?;
+            repo.add_all()?;
+            return Ok(());
+        }
+    } else {
+        format!("*.{ENCRYPTED_EXTENSION}")
+    };
+    let decrypt_results = repo
+        .ls_files_absolute_with_given_patterns(&[pattern.as_str()])?
         .par_iter()
         .filter(|x| x.is_file())
-        .filter(|x| {
-            if path.is_some() {
-                pattern
-                    .as_ref()
-                    .expect("path must be Some in this case")
-                    .matches(x.to_string_lossy().as_ref())
-            } else {
-                true
-            }
-        })
         .map(|f| decrypt_file(f, repo.get_key_sha()))
         .collect::<Vec<_>>();
-    decrypt_futures.par_iter().for_each(|ret| {
+    decrypt_results.par_iter().for_each(|ret| {
         if let Err(err) = ret {
             eprintln!(
                 "{}",

src/crypt.rs

@@ -17,20 +17,15 @@ use repo::Repo;
 pub use crate::cli::{Cli, SetField, SubCommand};
 
 #[allow(clippy::missing_panics_doc, clippy::missing_errors_doc)]
-pub fn run(cli: &Cli) -> Result<()> {
+pub fn run(cli: Cli) -> Result<()> {
     let repo = Repo::open(&cli.repo)?;
     let repo = Box::leak(Box::new(repo));
     let num_cpus = num_cpus::get();
     debug!("using blocking thread size: {}", num_cpus * 2);
-    match &cli.command {
+    match cli.command {
         SubCommand::Encrypt => encrypt_repo(repo)?,
-        SubCommand::Decrypt { path } => decrypt_repo(repo, path.as_ref())?,
-        SubCommand::Add { paths } => repo.conf.add_to_crypt_list(
-            &paths
-                .iter()
-                .map(std::convert::AsRef::as_ref)
-                .collect::<Vec<_>>(),
-        )?,
+        SubCommand::Decrypt { path } => decrypt_repo(repo, path)?,
+        SubCommand::Add { paths } => repo.conf.add_to_crypt_list(&paths)?,
         SubCommand::Set { field } => field.set(repo)?,
         SubCommand::Pwd => repo.set_key_interactive()?,
     }

src/lib.rs

@@ -4,7 +4,7 @@ use log::LevelFilter;
 
 fn main() -> anyhow::Result<()> {
     log_init();
-    run(&Cli::parse())
+    run(Cli::parse())
 }
 
 #[inline]