From 79ec6878877f0fd9246d67d3cd4f8cc2d1200150 Mon Sep 17 00:00:00 2001 From: 魏曹先生 <1992414357@qq.com> Date: Fri, 17 Jul 2026 11:08:07 +0800 Subject: refactor: rename `mingling_picker` to `arg_picker` --- mingling_picker/src/value/flag.rs | 145 --------------------------------- mingling_picker/src/value/vec_until.rs | 134 ------------------------------ 2 files changed, 279 deletions(-) delete mode 100644 mingling_picker/src/value/flag.rs delete mode 100644 mingling_picker/src/value/vec_until.rs (limited to 'mingling_picker/src/value') diff --git a/mingling_picker/src/value/flag.rs b/mingling_picker/src/value/flag.rs deleted file mode 100644 index ee0d6ee..0000000 --- a/mingling_picker/src/value/flag.rs +++ /dev/null @@ -1,145 +0,0 @@ -use std::{ - fmt::{Debug, Display}, - ops::{Deref, Not}, -}; - -/// Parsed result of a boolean-style command-line flag. -/// -/// `Flag` is a **value type** that can be declared in [`PickerArg`]. -/// When the user passes `--verbose` on the command line, the parsed result is `Flag::Active`; -/// when the flag is absent, the result is `Flag::Inactive`. -/// -/// # Why not just `bool`? -/// -/// Unlike a raw `bool`, `Flag` carries **explicit semantics** about whether -/// the flag was actually provided by the user (`Active`) or simply omitted -/// (`Inactive`). This distinction matters when you want to distinguish -/// "the user intentionally omitted the flag" from "the flag was processed but -/// resolved to false" — the `Pickable` implementation for `Flag` always -/// returns `Parsed(Flag::Inactive)` when no matching argument is found, -/// rather than `NotFound`, making it always succeed with a meaningful default. -/// -/// # Conversions -/// -/// `Flag` interoperates seamlessly with `bool`: `Flag::Active` is `true`, -/// `Flag::Inactive` is `false`. The [`Deref`] impl allows using a `Flag` -/// directly in boolean contexts: -/// -/// ``` -/// # use mingling_picker::value::Flag; -/// let flag = Flag::Active; -/// if *flag { /* runs */ } -/// ``` -/// -/// [`PickerArg`]: crate::PickerArg -#[derive(Default, Clone, Copy, PartialEq, Eq)] -pub enum Flag { - /// The flag was **not** present on the command line. - /// - /// This is the default state, equivalent to `false`. - #[default] - Inactive, - - /// The flag **was** present on the command line. - /// - /// Equivalent to `true`. - Active, -} - -impl Debug for Flag { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match self { - Self::Inactive => write!(f, "inactive"), - Self::Active => write!(f, "active"), - } - } -} - -impl Display for Flag { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match self { - Self::Inactive => write!(f, "inactive"), - Self::Active => write!(f, "active"), - } - } -} - -impl Flag { - /// Converts this `Flag` into a `bool`. - /// - /// Returns `true` if the flag is [`Active`], `false` if [`Inactive`]. - /// - /// # Examples - /// - /// ``` - /// # use mingling_picker::value::Flag; - /// assert!(Flag::Active.bool()); - /// assert!(!Flag::Inactive.bool()); - /// ``` - /// - /// [`Active`]: Flag::Active - /// [`Inactive`]: Flag::Inactive - #[must_use] - #[inline(always)] - pub fn bool(&self) -> bool { - *self == Flag::Active - } -} - -impl PartialEq for Flag { - fn eq(&self, other: &bool) -> bool { - self.bool() == *other - } -} - -/// Compares `bool` with `Flag` using `==`. -impl PartialEq for bool { - fn eq(&self, other: &Flag) -> bool { - *self == other.bool() - } -} - -impl From for Flag { - fn from(value: bool) -> Self { - if value { Flag::Active } else { Flag::Inactive } - } -} - -impl From for bool { - fn from(val: Flag) -> Self { - val == Flag::Active - } -} - -/// Allows `Flag` to be used in boolean contexts via `*flag`. -/// -/// # Examples -/// -/// ``` -/// # use mingling_picker::value::Flag; -/// let flag = Flag::Active; -/// if *flag { -/// println!("flag is set"); -/// } -/// ``` -impl Deref for Flag { - type Target = bool; - - fn deref(&self) -> &bool { - match self { - Flag::Active => &true, - Flag::Inactive => &false, - } - } -} - -impl Not for Flag { - type Output = Flag; - - fn not(self) -> Flag { - match self { - Flag::Active => Flag::Inactive, - Flag::Inactive => Flag::Active, - } - } -} diff --git a/mingling_picker/src/value/vec_until.rs b/mingling_picker/src/value/vec_until.rs deleted file mode 100644 index 1b79641..0000000 --- a/mingling_picker/src/value/vec_until.rs +++ /dev/null @@ -1,134 +0,0 @@ -use std::marker::PhantomData; -use std::ops::{Deref, DerefMut}; - -use crate::{ - BoundaryCheck, MultiPickableWithBoundary, Pickable, PickerArg, PickerArgAttr, PickerArgResult, - SinglePickable, TagPhaseContext, - matcher_needed::Matcher, - parselib::{MultiArgMatcher, ParserStyle}, -}; - -/// A `Vec`-like container that stops collecting when [`BoundaryCheck`] -/// returns `true`. -/// -/// This type exists to signal "I know what I'm doing with boundaries" -/// at the type level (as opposed to `Vec` which greedily takes -/// everything). -#[derive(Debug, Clone, PartialEq, Eq, Default)] -pub struct VecUntil { - pub(crate) inner: Vec, - _marker: PhantomData, -} - -impl VecUntil { - pub fn into_inner(self) -> Vec { - self.inner - } -} - -impl From> for VecUntil { - fn from(v: Vec) -> Self { - VecUntil { - inner: v, - _marker: PhantomData, - } - } -} - -impl From> for Vec { - fn from(v: VecUntil) -> Self { - v.inner - } -} - -impl Deref for VecUntil { - type Target = Vec; - fn deref(&self) -> &Vec { - &self.inner - } -} - -impl DerefMut for VecUntil { - fn deref_mut(&mut self) -> &mut Vec { - &mut self.inner - } -} - -// MultiPickableWithBoundary impl - -impl MultiPickableWithBoundary for VecUntil -where - T: SinglePickable + BoundaryCheck, -{ - type Checker = T; - - fn pick_multi(raw: Vec) -> PickerArgResult { - let mut inner = Vec::with_capacity(raw.len()); - for s in &raw { - match T::pick_single(Some(s)) { - PickerArgResult::Parsed(v) => inner.push(v), - PickerArgResult::NotFound => return PickerArgResult::NotFound, - PickerArgResult::Unparsed => {} - } - } - PickerArgResult::Parsed(VecUntil { - inner, - _marker: PhantomData, - }) - } -} - -// Pickable impl - -impl<'a, T> Pickable<'a> for VecUntil -where - T: SinglePickable + BoundaryCheck, -{ - fn get_attr(flag: &'a PickerArg<'a, Self>) -> PickerArgAttr { - PickerArgAttr::positional_or_multi(flag) - } - - fn tag(ctx: TagPhaseContext) -> Vec { - let args = ctx.args; - let is_positional = ctx.arg_info.positional; - let positions = MultiArgMatcher::match_all(ctx.into()); - if positions.is_empty() { - return positions; - } - - let start = if is_positional { 0 } else { 1 }; - if start >= positions.len() { - return positions; - } - - let mut cut = start; - for &idx in &positions[start..] { - if let Some(raw) = args.get(idx) - && T::check_boundary(raw) - { - break; - } - cut += 1; - } - - positions[..cut].to_vec() - } - - fn pick(raw_strs: &[&str]) -> PickerArgResult { - let strs = strip_flag(raw_strs); - let owned: Vec = strs.iter().map(|&s| s.to_string()).collect(); - as MultiPickableWithBoundary>::pick_multi(owned) - } -} - -/// If the first raw string looks like a named flag (starts with the -/// style's long or short prefix), strip it — it's the flag, not a value. -fn strip_flag<'a>(raw_strs: &'a [&'a str]) -> &'a [&'a str] { - if let Some(first) = raw_strs.first() { - let style = ParserStyle::global_style(); - if first.starts_with(style.long_prefix) || first.starts_with(style.short_prefix) { - return &raw_strs[1..]; - } - } - raw_strs -} -- cgit