Struct ApprovalQueue 

pub struct ApprovalQueue<T> { /* private fields */ }

A queue of pending items to approve, reject or skip. Returns an ApprovalReport.

Implementations

impl<T> ApprovalQueue<T>

pub fn new<I, V>(prompt: impl Into<String>, items: I) -> ApprovalQueue<T>

where I: IntoIterator<Item = V>, V: Into<Item<T>>,

pub fn height(self, rows: usize) -> Self

Show at most rows items at once (default 10).

pub fn preview(self, layout: PreviewLayout) -> Self

Where the detail pane goes (default: beside the list from 72 columns, below it when narrower); Hidden hides it.

pub fn preview_height(self, rows: usize) -> Self

Rows the detail pane takes when it is below the list (default 8).

pub fn theme(self, theme: Theme) -> Self

pub fn with_mouse(self, on: bool) -> Self

Report the mouse (#476): rows, the mark column and the buttons click, and the wheel moves.

pub fn rebind(self, action: &str, keys: impl IntoIterator<Item = Key>) -> Self

Make keys do action (see approve_keymap) on this queue only; no keys unbinds it.

pub fn require_reason(self, verdict: Verdict) -> Self

Ask for a reason whenever an item gets verdict (a rejection, say), and refuse an empty one.

pub fn advance(self, on: bool) -> Self

Whether a decision moves the cursor on to the next pending item (default on).

pub fn auto_submit(self, on: bool) -> Self

Submit by itself as soon as nothing is pending (default off: Enter submits).

pub fn decided( self, index: usize, verdict: Verdict, reason: Option<String>, ) -> Self

Start item index decided: a review picked up where it was left.

pub fn items(&self) -> &[Item<T>]

pub fn verdicts(&self) -> &[Verdict]

Each item’s verdict so far.

pub fn reason(&self, index: usize) -> Option<&str>

Item index’s reason, if it has one.

pub fn focused(&self) -> Option<usize>

The focused item’s index (none when the queue is empty).

pub fn marked(&self) -> Vec<usize>

The items marked for a bulk decision.

pub fn is_asking_reason(&self) -> bool

Whether a reason is being typed.

pub fn approve_keymap(&self) -> &Keymap

The keys, with any rebinding.

pub fn summary(&self) -> String

2 approved · 1 rejected · 0 skipped · 3 pending, so far.

impl<T: Clone> ApprovalQueue<T>

pub fn report(&self) -> ApprovalReport<T>

The report as things stand: every item with its decision so far.

Trait Implementations

impl<T: Clone> Component for ApprovalQueue<T>

fn default_value(&self) -> Option<ApprovalReport<T>>

The decisions as they stand: without a terminal and asked for defaults, nothing is decided.

type Output = ApprovalReport<T>

fn handle( &mut self, event: &Event, context: &Context<'_>, ) -> Flow<ApprovalReport<T>>

Handle one event. Ctrl+C never arrives here: the event loop ends the component with Outcome::Interrupted.

fn render(&self, context: &Context<'_>) -> View

Render the current state.

fn mouse(&self) -> bool

Whether the component wants mouse events (#476): clicks, drags and the wheel. Off by default, since reporting the mouse takes text selection away from the terminal; a component turns it on when its caller opts in, and run then enables mouse reporting for the session.

fn keymap(&self) -> Keymap

The bindings this component has right now, for a help overlay, a shortcut list or status-bar hints to read (see keymap). A container’s include its focused child’s, before its own. The default declares none.

fn prompt( &mut self, io: &mut dyn LineIo, ) -> Result<Option<ApprovalReport<T>>, NotInteractive>

Ask for the value line by line, for when the terminal is not interactive and the policy asks for a prompt. The default says the component has no line-based form.

fn start(&mut self, context: &Context<'_>) -> Flow<Self::Output>

Called once, before the component is first painted, with the terminal’s size: for work that needs it, such as rendering content at the width. Returning Done or Cancel finishes the component without waiting for an event. The default does nothing.

fn tick(&self) -> Option<Duration>

How often the component wants Event::Tick, for a spinner or a countdown. None (the default): never.

fn focusable(&self) -> bool

Whether the component takes focus in a container: Tab stops on it and keys go to it. The default: yes. A label, or a component that has finished, says no.

fn focus_step(&mut self, forward: bool) -> bool

Move focus to the next (forward) or previous focus stop inside this component, for Tab and Shift+Tab. false when there is none after the current one, so the container moves on to its next child. The default, for a component that is one stop: false.

fn focus_enter(&mut self, forward: bool) -> bool

Take focus from outside: at the first stop inside when forward, at the last otherwise. false when nothing in it can take focus. The default: whether the component is focusable.