retiretui 0.1.0

Retirement planning application for the terminal.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

//! A pick from a set too long for a menu: the select's button opens the
//! shell's fuzzy picker over its offers, and takes the choice as a menu's.

use bevy_ecs::prelude::{Commands, Entity, In, On, Query, Res, ResMut, Resource, World};
use plurimus::widgets::Activate;

use super::offers::Vocabulary;
use super::select::{PickChanged, Select};
use crate::commands::tui::picker::{Offered, Picker, Picking, ranked};

/// The pickers a searched select opens, and the select the one on show
/// answers to.
#[derive(Resource)]
pub struct Searches {
    countries: Picker,
    states: Picker,
    target: Option<Entity>,
}

pub fn register(world: &mut World) {
    let searches = Searches {
        countries: Picker::new(world, ("Country", "country"), list_offers, take_chosen),
        states: Picker::new(world, ("State", "state"), list_offers, take_chosen),
        target: None,
    };
    world.insert_resource(searches);
}

pub fn handle_search(
    activate: On<Activate>,
    selects: Query<&Select>,
    mut searches: ResMut<Searches>,
    mut picking: ResMut<Picking>,
) {
    let Some(vocabulary) = selects.get(activate.entity).ok().and_then(Select::searched) else {
        return;
    };
    let picker = match vocabulary {
        Vocabulary::Country => searches.countries,
        Vocabulary::UsState => searches.states,
        _ => return,
    };
    searches.target = Some(activate.entity);
    picking.open(picker);
}

/// The offers by the words shown for them, each beside the value kept; the
/// row past the last empties a field that may be empty.
fn list_offers(
    In(query): In<String>,
    searches: Res<Searches>,
    selects: Query<&Select>,
) -> Vec<Offered> {
    let Some(select) = searches.target.and_then(|target| selects.get(target).ok()) else {
        return Vec::new();
    };
    let (offers, blank) = select.offered();
    let listed = offers.iter().enumerate();
    let rows = listed.map(|(at, offer)| Offered::new(at, &offer.label).badged(&offer.value));
    let emptying = blank.map(|blank| Offered::new(offers.len(), blank).dimmed());
    ranked(&query, rows.chain(emptying))
}

fn take_chosen(
    In(chosen): In<usize>,
    searches: Res<Searches>,
    mut selects: Query<&mut Select>,
    mut commands: Commands,
) {
    let Some(entity) = searches.target else {
        return;
    };
    let Ok(mut select) = selects.get_mut(entity) else {
        return;
    };
    let value = select.choose(Some(chosen));
    commands.trigger(PickChanged { entity, value });
}