rollcli 0.3.3

A command-line dice roller for tabletop RPGs with advantage/disadvantage and probability estimation
Documentation 
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

pub mod app;
pub mod event;
pub mod theme;
pub mod ui;

use crossterm::ExecutableCommand as _;
use crossterm::event::Event;
use crossterm::terminal::{
    EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode,
};
use ratatui::Terminal;
use ratatui::backend::CrosstermBackend;
use std::io::{self, stdout};
use std::time::Duration;

use app::{App, PresetEntry};

// ── Preset helpers (bridge to main.rs preset system) ─────────────────────────

/// Load presets as a sorted Vec for the TUI.
pub fn load_presets_list() -> Vec<PresetEntry> {
    let home = std::env::var("HOME").unwrap_or_else(|_| ".".to_string());
    let path = std::path::PathBuf::from(home)
        .join(".config")
        .join("roll")
        .join("presets.toml");

    if !path.exists() {
        return Vec::new();
    }

    let content = std::fs::read_to_string(&path).unwrap_or_default();

    #[derive(serde::Deserialize, Default)]
    struct Presets {
        #[serde(default)]
        presets: std::collections::HashMap<String, String>,
    }

    let loaded: Presets = toml::from_str(&content).unwrap_or_default();
    let mut entries: Vec<PresetEntry> = loaded
        .presets
        .into_iter()
        .map(|(name, expression)| PresetEntry { name, expression })
        .collect();
    entries.sort_by(|a, b| a.name.cmp(&b.name));
    entries
}

/// Delete a preset by name.
pub fn delete_preset(name: &str) {
    let home = std::env::var("HOME").unwrap_or_else(|_| ".".to_string());
    let path = std::path::PathBuf::from(home)
        .join(".config")
        .join("roll")
        .join("presets.toml");

    if !path.exists() {
        return;
    }

    let content = std::fs::read_to_string(&path).unwrap_or_default();

    #[derive(serde::Serialize, serde::Deserialize, Default)]
    struct Presets {
        #[serde(default)]
        presets: std::collections::HashMap<String, String>,
    }

    let mut loaded: Presets = toml::from_str(&content).unwrap_or_default();
    loaded.presets.remove(name);

    if let Ok(serialized) = toml::to_string(&loaded) {
        let _ = std::fs::write(&path, serialized);
    }
}

// ── Terminal wrapper with drop-based cleanup ─────────────────────────────────

struct TerminalGuard {
    terminal: Terminal<CrosstermBackend<io::Stdout>>,
}

impl TerminalGuard {
    fn new() -> io::Result<Self> {
        enable_raw_mode()?;
        stdout().execute(EnterAlternateScreen)?;
        let backend = CrosstermBackend::new(stdout());
        let terminal = Terminal::new(backend)?;
        Ok(Self { terminal })
    }
}

impl Drop for TerminalGuard {
    fn drop(&mut self) {
        let _ = disable_raw_mode();
        let _ = stdout().execute(LeaveAlternateScreen);
    }
}

// ── Public entry point ───────────────────────────────────────────────────────

pub fn run(initial_expr: Option<&str>, sims: u64) -> io::Result<()> {
    let mut guard = TerminalGuard::new()?;
    let mut app = App::new(initial_expr, sims);

    // Load presets on startup
    app.reload_presets();

    // If initial expression was provided, roll it immediately
    if initial_expr.is_some() {
        app.submit_roll();
    }

    loop {
        guard.terminal.draw(|f| ui::draw(f, &app))?;

        if let Some(Event::Key(key)) = event::poll_event(Duration::from_millis(50))? {
            event::handle_key(&mut app, key);
        }

        if app.should_quit {
            break;
        }
    }

    Ok(())
}