rusticity-term 0.1.6

Terminal UI components for Rusticity
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

use crate::common::{translate_column, ColumnId};
use crate::ui::table::Column as TableColumn;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

pub fn init(i18n: &mut HashMap<String, String>) {
    for col in Column::all() {
        i18n.entry(col.id().to_string())
            .or_insert_with(|| col.default_name().to_string());
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct InstanceTag {
    pub key: String,
    pub value: String,
}

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Column {
    Key,
    Value,
}

impl Column {
    const ID_KEY: &'static str = "column.ec2.tag.key";
    const ID_VALUE: &'static str = "column.ec2.tag.value";

    pub const fn id(&self) -> ColumnId {
        match self {
            Column::Key => Self::ID_KEY,
            Column::Value => Self::ID_VALUE,
        }
    }

    pub const fn default_name(&self) -> &'static str {
        match self {
            Column::Key => "Key",
            Column::Value => "Value",
        }
    }

    pub fn name(&self) -> String {
        translate_column(self.id(), self.default_name())
    }

    pub fn from_id(id: &str) -> Option<Self> {
        match id {
            Self::ID_KEY => Some(Column::Key),
            Self::ID_VALUE => Some(Column::Value),
            _ => None,
        }
    }

    pub const fn all() -> [Column; 2] {
        [Column::Key, Column::Value]
    }

    pub fn ids() -> Vec<ColumnId> {
        Self::all().iter().map(|c| c.id()).collect()
    }
}

impl TableColumn<InstanceTag> for Column {
    fn name(&self) -> &str {
        Box::leak(translate_column(self.id(), self.default_name()).into_boxed_str())
    }

    fn width(&self) -> u16 {
        let translated = translate_column(self.id(), self.default_name());
        translated.len().max(20) as u16
    }

    fn render(&self, item: &InstanceTag) -> (String, ratatui::style::Style) {
        let text = match self {
            Column::Key => item.key.clone(),
            Column::Value => item.value.clone(),
        };
        (text, ratatui::style::Style::default())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_column_ids() {
        let ids = Column::ids();
        assert_eq!(ids.len(), 2);
        assert_eq!(ids[0], "column.ec2.tag.key");
        assert_eq!(ids[1], "column.ec2.tag.value");
    }

    #[test]
    fn test_column_from_id() {
        assert_eq!(Column::from_id("column.ec2.tag.key"), Some(Column::Key));
        assert_eq!(Column::from_id("column.ec2.tag.value"), Some(Column::Value));
        assert_eq!(Column::from_id("invalid"), None);
    }

    #[test]
    fn test_column_names() {
        assert_eq!(Column::Key.default_name(), "Key");
        assert_eq!(Column::Value.default_name(), "Value");
    }
}