temi 0.1.2

Command-line, lightweight TUI client for Lemmy
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use tui::widgets::ListState;

/// Represents a post creator as returned in a posts API response.
#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
pub struct Creator {
    pub id: u64,
    pub name: String,
    pub avatar: Option<String>,
    pub banned: bool,
    pub published: String,
    pub actor_id: String,
    pub local: bool,
    pub icon: Option<String>,
    pub deleted: bool,
    pub admin: Option<bool>,
    pub bot_account: bool,
    pub instance_id: u64,
}

impl Creator {
    /// Creates a new [Creator].
    pub const fn new() -> Self {
        Self {
            id: 0,
            name: String::new(),
            avatar: None,
            banned: false,
            published: String::new(),
            actor_id: String::new(),
            local: false,
            icon: None,
            deleted: false,
            admin: None,
            bot_account: false,
            instance_id: 0,
        }
    }

    /// Gets the [Creator] name.
    pub fn name(&self) -> &str {
        self.name.as_str()
    }

    /// Gets the [Creator] published date.
    pub fn published(&self) -> &str {
        self.published.as_str()
    }

    /// Gets the [Creator] icon URL.
    pub fn icon(&self) -> &str {
        self.icon.as_deref().unwrap_or("")
    }

    /// Gets the [Creator] avatar URL.
    pub fn avatar(&self) -> &str {
        self.avatar.as_deref().unwrap_or("")
    }
}

/// List of [Creator]s for displaying in the TUI.
#[derive(Clone, Debug)]
pub struct Creators {
    pub items: Vec<Creator>,
    pub state: ListState,
}

impl Creators {
    /// Creates a new [Creators].
    pub fn new(items: Vec<Creator>) -> Self {
        Self {
            items,
            state: ListState::default(),
        }
    }

    /// Gets the list of [Creator] items.
    pub fn items(&self) -> &[Creator] {
        self.items.as_ref()
    }

    /// Gets a reference to the current [ListState].
    pub fn state(&self) -> &ListState {
        &self.state
    }

    /// Gets a mutable reference to the current [ListState].
    pub fn state_mut(&mut self) -> &mut ListState {
        &mut self.state
    }

    /// Gets an optional reference to the currently selected [Creator].
    pub fn current(&self) -> Option<&Creator> {
        match self.state.selected() {
            Some(i) => Some(&self.items[i]),
            None => None,
        }
    }

    /// Clears the [ListState] selection.
    pub fn deselect(&mut self) {
        self.state.select(None);
    }

    /// Updates the [ListState] to select the next item.
    pub fn next(&mut self) {
        let i = match self.state.selected() {
            Some(i) => {
                if i >= self.items.len() {
                    0
                } else {
                    i + 1
                }
            }
            None => 0,
        };
        self.state.select(Some(i));
    }

    /// Updates the [ListState] to select the previous item.
    pub fn previous(&mut self) {
        let len = self.items.len();
        let last = len - 1;
        let i = match self.state.selected() {
            Some(i) => {
                if i == 0 {
                    last
                } else {
                    i.saturating_sub(1)
                }
            }
            None => last,
        };
        self.state.select(Some(i));
    }
}

impl AsRef<Creator> for Creator {
    fn as_ref(&self) -> &Self {
        self
    }
}

impl AsMut<Creator> for Creator {
    fn as_mut(&mut self) -> &mut Self {
        self
    }
}