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/vec_until.rs | 134 +++++++++++++++++++++++++++++++++
 1 file changed, 134 insertions(+)
 create mode 100644 mingling_picker/src/value/vec_until.rs

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

diff --git a/mingling_picker/src/value/vec_until.rs b/mingling_picker/src/value/vec_until.rs
new file mode 100644
index 0000000..1b79641
--- /dev/null
+++ b/mingling_picker/src/value/vec_until.rs
@@ -0,0 +1,134 @@
+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<T>` which greedily takes
+/// everything).
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
+pub struct VecUntil<T> {
+    pub(crate) inner: Vec<T>,
+    _marker: PhantomData<T>,
+}
+
+impl<T> VecUntil<T> {
+    pub fn into_inner(self) -> Vec<T> {
+        self.inner
+    }
+}
+
+impl<T> From<Vec<T>> for VecUntil<T> {
+    fn from(v: Vec<T>) -> Self {
+        VecUntil {
+            inner: v,
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<T> From<VecUntil<T>> for Vec<T> {
+    fn from(v: VecUntil<T>) -> Self {
+        v.inner
+    }
+}
+
+impl<T> Deref for VecUntil<T> {
+    type Target = Vec<T>;
+    fn deref(&self) -> &Vec<T> {
+        &self.inner
+    }
+}
+
+impl<T> DerefMut for VecUntil<T> {
+    fn deref_mut(&mut self) -> &mut Vec<T> {
+        &mut self.inner
+    }
+}
+
+// MultiPickableWithBoundary impl
+
+impl<T> MultiPickableWithBoundary for VecUntil<T>
+where
+    T: SinglePickable + BoundaryCheck,
+{
+    type Checker = T;
+
+    fn pick_multi(raw: Vec<String>) -> PickerArgResult<Self> {
+        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<T>
+where
+    T: SinglePickable + BoundaryCheck,
+{
+    fn get_attr(flag: &'a PickerArg<'a, Self>) -> PickerArgAttr {
+        PickerArgAttr::positional_or_multi(flag)
+    }
+
+    fn tag(ctx: TagPhaseContext) -> Vec<usize> {
+        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<Self> {
+        let strs = strip_flag(raw_strs);
+        let owned: Vec<String> = strs.iter().map(|&s| s.to_string()).collect();
+        <VecUntil<T> 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