refactor: rename `mingling_picker` to `arg_picker`

1 files changed, 0 insertions, 276 deletions

diff --git a/mingling_picker/src/parselib/utils.rs b/mingling_picker/src/parselib/utils.rs
deleted file mode 100644
index 47c5b55..0000000
--- a/mingling_picker/src/parselib/utils.rs
+++ /dev/null
@@ -1,276 +0,0 @@
-use crate::{
-    PickerArgInfo,
-    parselib::{MaskedArg, ParserStyle},
-};
-
-/// Builds a list of possible flag strings for the given argument info
-///
-/// This function generates formatted flag strings (e.g., `-h`, `--help`) from the short flag,
-/// long flag, and any aliases defined in the argument info. The long flag and alias names
-/// are converted according to the style's naming case convention before being formatted.
-#[inline(always)]
-pub fn build_possible_flags(style: &ParserStyle, arg_info: &PickerArgInfo) -> Vec<String> {
-    let mut possible_flags = vec![];
-
-    if let Some(short) = arg_info.short {
-        possible_flags.push(style.flag_string(short));
-    }
-
-    if let Some(long) = arg_info.long {
-        let converted = style.naming_case.convert(long.to_string());
-        possible_flags.push(style.flag_string(&converted));
-    }
-
-    if let Some(aliases) = &arg_info.alias {
-        for alias in aliases {
-            let converted = style.naming_case.convert(alias.to_string());
-            possible_flags.push(style.flag_string(&converted));
-        }
-    }
-
-    possible_flags
-}
-
-/// Extract a single value from the raw strings tagged by [`SingleMatcher`](crate::parselib::SingleMatcher).
-///
-/// Returns `None` if no value is available (empty slice),
-/// the inline value after the style separator if present (eq mode),
-/// or the value directly (positional or flag-following).
-///
-/// This is the standard `pick` helper for all `Single`-type
-/// [`Pickable`](crate::Pickable) implementations.
-#[must_use]
-pub fn seek_single<'a>(raw_strs: &'a [&'a str]) -> Option<&'a str> {
-    match raw_strs.len() {
-        0 => None,
-        1 => {
-            let s = raw_strs[0];
-            let sep = ParserStyle::global_style().value_separator;
-            if let Some(pos) = s.rfind(sep) {
-                Some(&s[pos + 1..])
-            } else {
-                Some(s)
-            }
-        }
-        _ => Some(raw_strs[1]),
-    }
-}
-
-/// Seeks the index of the end-of-options marker (`--`) in the argument list.
-///
-/// This function searches for the standard end-of-options separator (`--`)
-/// in the given argument list, respecting the parser's style settings
-/// (e.g., case sensitivity). The end-of-options marker indicates that all
-/// subsequent arguments should be treated as positional arguments, not flags.
-#[must_use]
-pub fn seek_end_of_options(args: &[MaskedArg], style: &ParserStyle) -> Option<usize> {
-    args.iter()
-        .find(|arg| {
-            if style.case_sensitive {
-                arg.raw == style.end_of_options
-            } else {
-                arg.raw.eq_ignore_ascii_case(style.end_of_options)
-            }
-        })
-        .map(|arg| arg.raw_idx)
-}
-
-/// Seeks arguments in `args` that are exactly equal to the given `string`.
-///
-/// Returns the indices of matching arguments.
-#[must_use]
-#[inline(always)]
-pub fn seek_eq(args: &[MaskedArg], string: &str, case_sensitive: bool) -> Vec<usize> {
-    args.iter()
-        .filter(|arg| {
-            if case_sensitive {
-                arg.raw == string
-            } else {
-                arg.raw.eq_ignore_ascii_case(string)
-            }
-        })
-        .map(|arg| arg.raw_idx)
-        .collect()
-}
-
-/// Seeks arguments in `args` that contain the given `string` as a substring.
-///
-/// Returns the indices of matching arguments.
-#[must_use]
-#[inline(always)]
-pub fn seek_contains(args: &[MaskedArg], string: &str, case_sensitive: bool) -> Vec<usize> {
-    args.iter()
-        .filter(|arg| {
-            if case_sensitive {
-                arg.raw.contains(string)
-            } else {
-                arg.raw.to_lowercase().contains(&string.to_lowercase())
-            }
-        })
-        .map(|arg| arg.raw_idx)
-        .collect()
-}
-
-/// Seeks arguments in `args` that start with the given `string`.
-///
-/// Returns the indices of matching arguments.
-#[must_use]
-#[inline(always)]
-pub fn seek_start_with(args: &[MaskedArg], string: &str, case_sensitive: bool) -> Vec<usize> {
-    args.iter()
-        .filter(|arg| {
-            if case_sensitive {
-                arg.raw.starts_with(string)
-            } else {
-                arg.raw.to_lowercase().starts_with(&string.to_lowercase())
-            }
-        })
-        .map(|arg| arg.raw_idx)
-        .collect()
-}
-
-/// Seeks arguments in `args` that end with the given `string`.
-///
-/// Returns the indices of matching arguments.
-#[must_use]
-#[inline(always)]
-pub fn seek_end_with(args: &[MaskedArg], string: &str, case_sensitive: bool) -> Vec<usize> {
-    args.iter()
-        .filter(|arg| {
-            if case_sensitive {
-                arg.raw.ends_with(string)
-            } else {
-                arg.raw.to_lowercase().ends_with(&string.to_lowercase())
-            }
-        })
-        .map(|arg| arg.raw_idx)
-        .collect()
-}
-
-/// Seeks arguments in `args` that are exactly equal to any of the given `strings`.
-///
-/// Returns the indices of matching arguments.
-#[must_use]
-#[inline(always)]
-pub fn multi_seek_eq(args: &[MaskedArg], strings: &[&str], case_sensitive: bool) -> Vec<usize> {
-    args.iter()
-        .filter(|arg| {
-            if case_sensitive {
-                strings.contains(&arg.raw)
-            } else {
-                strings.iter().any(|s| arg.raw.eq_ignore_ascii_case(s))
-            }
-        })
-        .map(|arg| arg.raw_idx)
-        .collect()
-}
-
-/// Seeks arguments in `args` that contain any of the given `strings` as a substring.
-///
-/// Returns the indices of matching arguments.
-#[must_use]
-#[inline(always)]
-pub fn multi_seek_contains(
-    args: &[MaskedArg],
-    strings: &[&str],
-    case_sensitive: bool,
-) -> Vec<usize> {
-    args.iter()
-        .filter(|arg| {
-            if case_sensitive {
-                strings.iter().any(|s| arg.raw.contains(s))
-            } else {
-                let lower_raw = arg.raw.to_lowercase();
-                strings
-                    .iter()
-                    .any(|s| lower_raw.contains(&s.to_lowercase()))
-            }
-        })
-        .map(|arg| arg.raw_idx)
-        .collect()
-}
-
-/// Seeks arguments in `args` that start with any of the given `strings`.
-///
-/// Returns the indices of matching arguments.
-#[must_use]
-#[inline(always)]
-pub fn multi_seek_start_with(
-    args: &[MaskedArg],
-    strings: &[&str],
-    case_sensitive: bool,
-) -> Vec<usize> {
-    args.iter()
-        .filter(|arg| {
-            if case_sensitive {
-                strings.iter().any(|s| arg.raw.starts_with(s))
-            } else {
-                let lower_raw = arg.raw.to_lowercase();
-                strings
-                    .iter()
-                    .any(|s| lower_raw.starts_with(&s.to_lowercase()))
-            }
-        })
-        .map(|arg| arg.raw_idx)
-        .collect()
-}
-
-/// Seeks arguments in `args` that end with any of the given `strings`.
-///
-/// Returns the indices of matching arguments.
-#[must_use]
-#[inline(always)]
-pub fn multi_seek_end_with(
-    args: &[MaskedArg],
-    strings: &[&str],
-    case_sensitive: bool,
-) -> Vec<usize> {
-    args.iter()
-        .filter(|arg| {
-            if case_sensitive {
-                strings.iter().any(|s| arg.raw.ends_with(s))
-            } else {
-                let lower_raw = arg.raw.to_lowercase();
-                strings
-                    .iter()
-                    .any(|s| lower_raw.ends_with(&s.to_lowercase()))
-            }
-        })
-        .map(|arg| arg.raw_idx)
-        .collect()
-}
-
-/// Converts a `&Vec<String>` into a `Vec<&str>` by borrowing each string's slice.
-///
-/// This is useful for converting owned `String` vectors into borrowed `&str` slices
-/// for functions that take `&[&str]` or similar parameters.
-#[must_use]
-#[inline(always)]
-#[doc(hidden)]
-pub fn vec_string_to_vec_str(input: &[String]) -> Vec<&str> {
-    input.iter().map(|s| s.as_str()).collect()
-}
-
-/// Converts a `&Vec<String>` into a `Vec<&str>` by borrowing each string's slice.
-///
-/// This is useful for converting owned `String` vectors into borrowed `&str` slices
-/// for functions that take `&[&str]` or similar parameters.
-#[macro_export]
-#[doc(hidden)]
-macro_rules! vec_string_slice {
-    ($v:expr) => {
-        $v.iter()
-            .map(|s| s.as_str())
-            .collect::<Vec<&str>>()
-            .as_slice()
-    };
-}
-
-/// Gets the first element from a vector of seek results, if any.
-///
-/// Returns `Some(index)` if the vector is non-empty, otherwise `None`.
-#[must_use]
-#[inline(always)]
-pub fn get_seeked_first(seeked: Vec<usize>) -> Option<usize> {
-    seeked.into_iter().next()
-}