tuika 0.11.1

The application framework for Rust terminal UIs — flexbox layout, overlays, focus, keymap, components, and safe ratatui interoperability.
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

use std::io;
use std::path::PathBuf;

use tuika::Theme;

/// Common command-line options shared by the runnable examples.
pub struct Cli {
    pub theme: Theme,
    #[allow(dead_code)]
    pub theme_name: Option<String>,
    #[allow(dead_code)]
    pub args: Vec<String>,
}

#[derive(Debug, Eq, PartialEq)]
#[allow(dead_code)]
pub enum Output {
    Terminal,
    Svg(PathBuf),
}

impl Output {
    #[allow(dead_code)]
    pub fn parse(args: &[String]) -> io::Result<Self> {
        match args {
            [] => Ok(Self::Terminal),
            [path] if !path.starts_with('-') => Ok(Self::Svg(PathBuf::from(path))),
            _ => Err(io::Error::new(
                io::ErrorKind::InvalidInput,
                "expected at most one SVG output path",
            )),
        }
    }
}

impl Cli {
    pub fn parse() -> io::Result<Self> {
        Self::parse_from(std::env::args().skip(1))
    }

    pub(crate) fn parse_from(args: impl IntoIterator<Item = String>) -> io::Result<Self> {
        let mut args = args.into_iter();
        let mut rest = Vec::new();
        let mut theme_name = None;

        while let Some(arg) = args.next() {
            if arg == "--theme" {
                let name = args
                    .next()
                    .ok_or_else(|| invalid_theme("missing theme name"))?;
                set_theme_name(&mut theme_name, name)?;
            } else if let Some(name) = arg.strip_prefix("--theme=") {
                set_theme_name(&mut theme_name, name.to_owned())?;
            } else {
                rest.push(arg);
            }
        }

        let theme = match theme_name.as_deref() {
            Some(name) => tuika::themes::by_name(name)
                .ok_or_else(|| invalid_theme(&format!("unknown theme {name:?}")))?,
            None => Theme::default(),
        };
        Ok(Self {
            theme,
            theme_name,
            args: rest,
        })
    }
}

fn set_theme_name(current: &mut Option<String>, name: String) -> io::Result<()> {
    if current.replace(name).is_some() {
        return Err(invalid_theme("--theme may only be supplied once"));
    }
    Ok(())
}

fn invalid_theme(detail: &str) -> io::Error {
    let names = tuika::themes::PRESETS
        .iter()
        .map(|preset| preset.name)
        .collect::<Vec<_>>()
        .join(", ");
    io::Error::new(
        io::ErrorKind::InvalidInput,
        format!("{detail}; available themes: {names}"),
    )
}