Cargo.lock

@@ -349,6 +349,12 @@ version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0d6ef0072f8a535281e4876be788938b528e9a1d43900b82c2569af7da799125"
 
+[[package]]
+name = "either"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
+
 [[package]]
 name = "env_logger"
 version = "0.10.2"
@@ -708,6 +714,7 @@ dependencies = [
  "clap",
  "clap_complete",
  "directories",
+ "either",
  "inquire",
  "log",
  "passwords",

Cargo.toml

@@ -32,6 +32,7 @@ base64 = "0.22.1"
 clap_complete = "4.5.2"
 totp-lite = "2.0.1"
 base32 = "0.5.0"
+either = { version = "1.13.0", default-features = false }
 
 [features]
 default = ["update-notify"]

src/clap_parsers.rs

@@ -14,9 +14,14 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://gnu.org/licenses/gpl-3.0.html>.
 
+use std::{fmt::Display, str::FromStr};
+
+use either::Either::{self, Left, Right};
+
 use crate::{LprsError, LprsResult};
 
 /// Parse the key & value arguments.
+///
 /// ## Errors
 /// - If the argument value syntax not `key=value`
 pub fn kv_parser(value: &str) -> LprsResult<(String, Option<String>)> {
@@ -30,3 +35,27 @@ pub fn kv_parser(value: &str) -> LprsResult<(String, Option<String>)> {
         Ok((value.trim().to_owned(), None))
     }
 }
+
+/// Parse `Either` type arguments.
+///
+/// ## Errors
+/// - If the argument value can't be parsed to `L` or `R`
+pub fn either_parser<L, R>(value: &str) -> LprsResult<Either<L, R>>
+where
+    L: FromStr,
+    R: FromStr,
+    <L as FromStr>::Err: Display,
+    <R as FromStr>::Err: Display,
+{
+    value
+        .trim()
+        .parse::<L>()
+        .map_err(|err| LprsError::ArgParse(err.to_string()))
+        .map(Left)
+        .or_else(|_| {
+            value
+                .parse::<R>()
+                .map_err(|err| LprsError::ArgParse(err.to_string()))
+                .map(Right)
+        })
+}

src/cli/edit_command.rs

@@ -14,10 +14,13 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://gnu.org/licenses/gpl-3.0.html>.
 
+use std::num::NonZeroUsize;
+
 use clap::Args;
+use either::Either;
 
 use crate::{
-    clap_parsers,
+    clap_parsers::{either_parser, kv_parser},
     utils,
     vault::{cipher, Vaults},
     LprsCommand,
@@ -29,8 +32,8 @@ use crate::{
 /// Edit command, used to edit the vault content
 pub struct Edit {
     /// The vault to edit, index or name
-    #[arg(name = "INDEX-or-NAME")]
+    #[arg(name = "INDEX-or-NAME", value_parser = either_parser::<NonZeroUsize, String>)]
-    location: String,
+    location: Either<NonZeroUsize, String>,
 
     #[arg(short, long)]
     /// The new vault name
@@ -61,7 +64,7 @@ pub struct Edit {
     /// If the custom field not exist will created it, if it's will update it,
     /// if there is no value, you will enter it through a prompt (e.g `-c key`)
     #[arg(name = "KEY=VALUE", short = 'c', long = "custom")]
-    #[arg(value_parser = clap_parsers::kv_parser)]
+    #[arg(value_parser = kv_parser)]
     custom_fields: Vec<(String, Option<String>)>,
     /// Force edit, will not return error if there is a problem with the args.
     ///
@@ -72,16 +75,15 @@ pub struct Edit {
 
 impl LprsCommand for Edit {
     fn run(self, mut vault_manager: Vaults) -> LprsResult<()> {
-        let vault =
+        let vault = match utils::vault_by_index_or_name(self.location, &mut vault_manager.vaults) {
-            match utils::vault_by_index_or_name(self.location.trim(), &mut vault_manager.vaults) {
+            Ok((_, v)) => v,
-                Ok((_, v)) => v,
+            Err(err) => {
-                Err(err) => {
+                if self.force {
-                    if self.force {
+                    return Ok(());
-                        return Ok(());
-                    }
-                    return Err(err);
                 }
-            };
+                return Err(err);
+            }
+        };
 
         log::info!("Applying the new values to the vault");
         if let Some(new_name) = self.name {

src/cli/get_command.rs

@@ -14,11 +14,13 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://gnu.org/licenses/gpl-3.0.html>.
 
-use std::str::FromStr;
+use std::{num::NonZeroUsize, str::FromStr};
 
 use clap::Args;
+use either::Either;
 
 use crate::{
+    clap_parsers::either_parser,
     utils,
     vault::{cipher, Vault, Vaults},
     LprsCommand,
@@ -94,8 +96,9 @@ impl VaultGetField {
 /// Command to get a entire vault or single field from it
 pub struct Get {
     /// Whether the index of the vault or its name
-    #[arg(value_name = "INDEX-or-NAME")]
+    #[arg(name = "INDEX-or-NAME", value_parser = either_parser::<NonZeroUsize, String>)]
-    location: String,
+    location: Either<NonZeroUsize, String>,
+
     /// A Specific field to get.
     ///
     /// Can be [name, username, password, service, note, totp_secret, totp_code,
@@ -103,13 +106,13 @@ pub struct Get {
     ///
     /// where the string means a custom field
     #[arg(value_parser = VaultGetField::from_str)]
-    field:    Option<VaultGetField>,
+    field: Option<VaultGetField>,
 }
 
 impl LprsCommand for Get {
     fn run(self, mut vault_manager: Vaults) -> LprsResult<()> {
         let (index, vault) =
-            utils::vault_by_index_or_name(self.location.trim(), &mut vault_manager.vaults)?;
+            utils::vault_by_index_or_name(self.location, &mut vault_manager.vaults)?;
 
         if let Some(field) = self.field {
             if field == VaultGetField::Index {

src/cli/remove_command.rs

@@ -14,16 +14,19 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://gnu.org/licenses/gpl-3.0.html>.
 
-use clap::Args;
+use std::num::NonZeroUsize;
 
-use crate::{utils, vault::Vaults, LprsCommand, LprsResult};
+use clap::Args;
+use either::Either;
+
+use crate::{clap_parsers::either_parser, utils, vault::Vaults, LprsCommand, LprsResult};
 
 #[derive(Debug, Args)]
 /// Remove command, used to remove a vault from the vaults file
 pub struct Remove {
     /// The vault to remove, index or name
-    #[arg(name = "INDEX-or-NAME")]
+    #[arg(name = "INDEX-or-NAME", value_parser = either_parser::<NonZeroUsize, String>)]
-    location: String,
+    location: Either<NonZeroUsize, String>,
 
     /// Force remove, will not return error if there is no vault with the given
     /// index or name
@@ -33,16 +36,15 @@ pub struct Remove {
 
 impl LprsCommand for Remove {
     fn run(self, mut vault_manager: Vaults) -> LprsResult<()> {
-        let index =
+        let index = match utils::vault_by_index_or_name(self.location, &mut vault_manager.vaults) {
-            match utils::vault_by_index_or_name(self.location.trim(), &mut vault_manager.vaults) {
+            Ok((idx, _)) => idx,
-                Ok((idx, _)) => idx,
+            Err(err) => {
-                Err(err) => {
+                if self.force {
-                    if self.force {
+                    return Ok(());
-                        return Ok(());
-                    }
-                    return Err(err);
                 }
-            };
+                return Err(err);
+            }
+        };
         vault_manager.vaults.remove(index);
         vault_manager.try_export()
     }

src/utils.rs

@@ -15,8 +15,10 @@
 // along with this program. If not, see <https://gnu.org/licenses/gpl-3.0.html>.
 
 use std::collections::BTreeMap;
+use std::num::NonZeroUsize;
 use std::{fs, path::PathBuf};
 
+use either::Either;
 use inquire::{validator::Validation, Password, PasswordDisplayMode};
 use passwords::{analyzer, scorer};
 #[cfg(feature = "update-notify")]
@@ -231,35 +233,31 @@ pub fn prompt_custom(
     Ok(new_fields)
 }
 
-/// Returns the vault with its index by its index or name
+/// Returns the vault with its index by either its index or name
 ///
 /// ## Errors
 /// - If there is no vault with the given index or name
-pub fn vault_by_index_or_name<'a>(
+pub fn vault_by_index_or_name(
-    index_or_name: &str,
+    location: Either<NonZeroUsize, String>,
-    vaults: &'a mut [Vault],
+    vaults: &mut [Vault],
-) -> LprsResult<(usize, &'a mut Vault)> {
+) -> LprsResult<(usize, &mut Vault)> {
-    let parsed_index = index_or_name.parse::<usize>();
+    let idx = location
+        .map_right(|name| {
+            vaults
+                .iter()
+                .enumerate()
+                .find_map(|(idx, v)| (v.name == name).then_some(idx))
+                .ok_or_else(|| {
+                    LprsError::Other(format!("There is no vault with the given name `{name}`"))
+                })
+        })
+        .map_left(|idx| LprsResult::Ok(idx.get() - 1))
+        .into_inner()?;
 
-    let Some((index, vault)) = (if let Ok(index) = parsed_index {
+    Ok((
-        index
+        idx,
-            .checked_sub(1)
+        vaults.get_mut(idx).ok_or_else(|| {
-            .and_then(|zeroindex| vaults.get_mut(zeroindex).map(|v| (index, v)))
+            LprsError::Other(format!("There is no vault with the given index `{idx}`"))
-    } else {
+        })?,
-        vaults
+    ))
-            .iter_mut()
-            .enumerate()
-            .find(|(_, v)| v.name == index_or_name)
-    }) else {
-        return Err(LprsError::Other(format!(
-            "There is no vault with the given {} `{}`",
-            if parsed_index.is_ok() {
-                "index"
-            } else {
-                "name"
-            },
-            index_or_name,
-        )));
-    };
-    Ok((index, vault))
 }