From b9f208deed7b8e012fbcd84202e2fb1d5eb8eeb9 Mon Sep 17 00:00:00 2001
From: 魏曹先生 <1992414357@qq.com>
Date: Fri, 17 Jul 2026 03:24:51 +0800
Subject: feat(picker2): complete Picker2 prototype
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Picker2 replaces the original Picker1 with a two-phase (tag → pick) +
mask-bitmap architecture, decoupling argument matching from type
conversion via a composable matcher pipeline.

Architecture
- FlagMatcher — boolean flags (--verbose)
- ArgMatcher — single flag+value pairs (--name Alice)
- MultiArgMatcher — multi-value flag groups (--files a.txt b.txt)
- PositionalMatcher — positional arguments, respects `--`
- SingleMatcher — composite for Single-type Pickables

Types
- Flag (Active/Inactive) — semantic bool flag value
- String + 14 numeric types via SinglePickable trait
- Vec<T> — greedy multi-value (all SinglePickable types)
- VecUntil<T> — bounded multi-value via BoundaryCheck trait
- VecUntil<T>, pick_string, pick_numbers, pick_bool, pick_flag

Style system
- UNIX_STYLE (kebab), POWERSHELL_STYLE (Pascal), WINDOWS_STYLE (Pascal)
- naming_case auto-conversion via just_fmt integration
- Style-aware separator (= for Unix, : for PS/Windows)

Infrastructure
- internal_repeat! macro generates PickerPattern1..=32
- SinglePickable blanket impl → Pickable
- MultiPickableWithBoundary trait with greedy/bounded variants
- 151 integration tests
- Docs updated for parser feature
---
 mingling_picker/src/value/flag.rs | 145 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 145 insertions(+)
 create mode 100644 mingling_picker/src/value/flag.rs

(limited to 'mingling_picker/src/value/flag.rs')

diff --git a/mingling_picker/src/value/flag.rs b/mingling_picker/src/value/flag.rs
new file mode 100644
index 0000000..ee0d6ee
--- /dev/null
+++ b/mingling_picker/src/value/flag.rs
@@ -0,0 +1,145 @@
+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<bool> for Flag {
+    fn eq(&self, other: &bool) -> bool {
+        self.bool() == *other
+    }
+}
+
+/// Compares `bool` with `Flag` using `==`.
+impl PartialEq<Flag> for bool {
+    fn eq(&self, other: &Flag) -> bool {
+        *self == other.bool()
+    }
+}
+
+impl From<bool> for Flag {
+    fn from(value: bool) -> Self {
+        if value { Flag::Active } else { Flag::Inactive }
+    }
+}
+
+impl From<Flag> 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,
+        }
+    }
+}
-- 
cgit