Struct Selection 

pub struct Selection { /* private fields */ }

A resolved, ordered, immutable snapshot of the issues a bulk operation acts on.

Built by Selection::resolve. The store is read; nothing is written, and there is no method on this type that can write — that is the property contract §3 needs, and it is structural rather than a promise.

Implementations

impl Selection

pub fn resolve( store: &Store, selectors: &[String], query: Option<&str>, source: SelectionSource, scope: SelectionScope, ) -> Result<Self>

Resolve a selection from explicit selectors and/or a query.

Resolution order, and why: explicit selectors first, then the query’s issues, then de-duplication. A user who typed both means the union, and taking the union in that order means the explicit ones lead — which is what a dry run should show first.

Ambiguity and not-found are the existing diagnostics, propagated unwrapped (contract §2). The first version wrapped the selector failure in a fresh NotFound, and the user saw not found: not found: issue matching … — the same doubled prefix a relationship message had. One message, from one place.

pub fn from_issues( issues: impl IntoIterator<Item = Issue>, source: SelectionSource, scope: SelectionScope, ) -> Self

A snapshot from issues the caller already has, with no store involved.

Two callers need this and neither is a test: the TUI multi-select (WP07) resolves a selection from the board’s cards rather than from typed selectors, and a caller previewing a large in-memory set has no store to resolve against. Both want the same guarantee — a value that cannot grow — which is what makes this a constructor on the type rather than a pub field.

The order is preserved rather than sorted: a board’s column order is what a user sees, and a selection’s order is presentation (the fingerprint is the order-insensitive part, and is the thing an apply is authorized for).

Numbers are de-duplicated, because a board can list the same issue twice and a plan that writes it twice is the failure the data-model calls “the plan never double-writes an issue unintentionally”.

pub fn issues(&self) -> &[Issue]

The issues, in the snapshot’s order.

pub fn into_issues(self) -> Vec<Issue>

Take the snapshot, so a later stage owns it rather than borrowing.

pub fn source(&self) -> SelectionSource

pub fn query(&self) -> Option<&str>

pub fn scope(&self) -> SelectionScope

pub fn selectors(&self) -> &[String]

The selectors after de-duplication, in the order they resolved.

pub fn duplicates(&self) -> &[String]

Selectors that named an issue an earlier selector had already named.

Reported rather than silently dropped: a user who typed 12 12 alpha and sees “3 issues” would otherwise have no way to know the third selector was ignored. The plan renders this (WP02 T009).

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn numbers(&self) -> Vec<u32>

The issue numbers, for a confirmation echo.

pub fn fingerprint(&self) -> Vec<u32>

A stable identity for this selection, so an apply can refuse a plan that was confirmed against a different snapshot (contract §4: “apply requires the exact confirmed plan”).

Built from the numbers, not from a hash of the issue contents: a user may edit a selected issue between preview and apply, and the plan still applies to those issues — the values were validated at preview time and re-validated at apply time, so a content hash would refuse a legitimate apply for the wrong reason. Membership is what has to match.

pub fn matches_fingerprint(&self, fingerprint: &[u32]) -> bool

Whether this selection matches a fingerprint, ignoring order.

Order-insensitive on purpose. A selection’s order is presentation; its membership is what an apply is authorized for, and rejecting an apply because the board came back in a different order would be a refusal with no user-visible cause.

Trait Implementations

impl Clone for Selection

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Selection

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Selection

impl PartialEq for Selection

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Selection