amoxide-tui 0.8.0

Interactive TUI for amoxide — manage aliases and profiles visually
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

use amoxide::effects::Effect;
use amoxide::update::UpdateError;
use amoxide::Message;

use crate::model::TuiModel;

/// Execute a library message against the model.
/// On success, executes all effects and rebuilds the tree.
/// On `UpdateError`, stores a TUI-friendly message in `status_line` and returns Ok(()).
pub fn dispatch(model: &mut TuiModel, msg: Message) -> anyhow::Result<()> {
    let result = match amoxide::update::update(&mut model.app_model, msg) {
        Ok(r) => r,
        Err(e) => {
            model.status_line = Some(tui_error_message(&e));
            return Ok(());
        }
    };

    execute_effects(model, &result.effects)?;

    if let Some(follow_up) = result.next {
        return dispatch(model, follow_up);
    }

    model.rebuild_tree();
    Ok(())
}

fn execute_effects(model: &mut TuiModel, effects: &[Effect]) -> anyhow::Result<()> {
    for effect in effects {
        match effect {
            Effect::Print(text) => {
                model.status_line = Some(text.clone());
            }
            other => {
                amoxide::execute_effect(&mut model.app_model, other)?;
            }
        }
    }
    Ok(())
}

fn tui_error_message(err: &UpdateError) -> String {
    match err {
        UpdateError::ProjectNotTrusted { .. } => "press 't' to trust this project".to_string(),
        UpdateError::AliasNotFound { name, .. } => format!("alias '{name}' not found"),
        UpdateError::ProfileNotFound { name } => format!("profile '{name}' not found"),
        UpdateError::NoProjectFile => "no .aliases file in this tree".to_string(),
        UpdateError::Other(e) => format!("error: {e}"),
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::model::{Column, Mode, TuiModel};
    use amoxide::update::AppModel;
    use amoxide::{AliasTarget, Config, Message, ProfileConfig};
    use std::collections::BTreeSet;

    fn make_model() -> TuiModel {
        let app_model = AppModel::new(Config::default(), ProfileConfig::default());
        let tree = crate::tree::build_tree(&app_model);
        let dest_tree = crate::tree::build_dest_tree(&app_model);
        TuiModel {
            app_model,
            tree,
            cursor: 0,
            selected: BTreeSet::new(),
            mode: Mode::Normal,
            dest_tree,
            dest_cursor: 0,
            active_column: Column::Left,
            scroll_offset: 0,
            status_line: None,
        }
    }

    #[test]
    fn dispatch_successful_mutation_rebuilds_tree() {
        let mut model = make_model();
        dispatch(
            &mut model,
            Message::AddAlias("ll".into(), "ls -lha".into(), AliasTarget::Global, false),
        )
        .unwrap();

        assert!(!model.tree.is_empty());
        assert!(model.status_line.is_none());
    }

    #[test]
    fn dispatch_project_not_trusted_sets_status_line() {
        let dir = tempfile::tempdir().unwrap();
        let aliases_path = dir.path().join(".aliases");
        std::fs::write(&aliases_path, "[aliases]\nt = \"cargo test\"\n").unwrap();
        let mut security = amoxide::security::SecurityConfig::default();
        security.untrust(&aliases_path);
        let app_model =
            AppModel::new_with_security(Config::default(), ProfileConfig::default(), security)
                .with_cwd(dir.path().to_path_buf());
        let tree = crate::tree::build_tree(&app_model);
        let dest_tree = crate::tree::build_dest_tree(&app_model);
        let mut model = TuiModel {
            app_model,
            tree,
            cursor: 0,
            selected: BTreeSet::new(),
            mode: Mode::Normal,
            dest_tree,
            dest_cursor: 0,
            active_column: Column::Left,
            scroll_offset: 0,
            status_line: None,
        };

        dispatch(
            &mut model,
            Message::AddAlias("t".into(), "cargo test".into(), AliasTarget::Local, false),
        )
        .unwrap();

        assert!(model.status_line.is_some());
        let msg = model.status_line.as_ref().unwrap();
        assert!(msg.contains("trust"), "expected trust message, got: {msg}");
    }

    #[test]
    fn dispatch_print_effect_goes_to_status_line() {
        let mut model = make_model();
        // CreateProfile returns no Print effect, just SaveProfiles — but ToggleProfiles emits Print
        let profile_config: amoxide::ProfileConfig =
            toml::from_str("[[profiles]]\nname = \"git\"\n").unwrap();
        let app_model = AppModel::new(Config::default(), profile_config);
        let tree = crate::tree::build_tree(&app_model);
        let dest_tree = crate::tree::build_dest_tree(&app_model);
        model.app_model = app_model;
        model.tree = tree;
        model.dest_tree = dest_tree;

        dispatch(&mut model, Message::ToggleProfiles(vec!["git".into()])).unwrap();

        // ToggleProfiles emits a Print effect with activation message
        assert!(model.status_line.is_some());
        let msg = model.status_line.as_ref().unwrap();
        assert!(
            msg.contains("git"),
            "expected profile name in status, got: {msg}"
        );
    }
}