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
148
149
150
151
152
153
154
155
156
157
158

use tui::widgets::ListState;

/// Represents a post as returned in a posts API response.
#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
pub struct Post {
    pub id: u64,
    pub name: String,
    pub url: Option<String>,
    pub deleted: bool,
    pub nsfw: bool,
    pub thumbnail_url: Option<String>,
    pub ap_id: String,
    pub body: Option<String>,
    pub sorted: Option<bool>,
}

impl Post {
    /// Creates a new [Post].
    pub const fn new() -> Self {
        Self {
            id: 0,
            name: String::new(),
            url: None,
            deleted: false,
            nsfw: false,
            thumbnail_url: None,
            ap_id: String::new(),
            body: None,
            sorted: None,
        }
    }

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

    /// Gets the [Post] ID.
    pub const fn id(&self) -> u64 {
        self.id
    }

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

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

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

    /// Gets the [Post] AP ID.
    pub fn ap_id(&self) -> &str {
        self.ap_id.as_str()
    }

    pub fn sorted(&self) -> bool {
        matches!(self.sorted, Some(true))
    }

    pub fn set_sorted(&mut self, val: bool) {
        self.sorted = Some(val);
    }

    pub fn unset_sorted(&mut self) {
        self.sorted.take();
    }
}

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

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

    /// Gets the list of [Post] items.
    pub fn items(&self) -> &[Post] {
        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 [Post].
    pub fn current(&self) -> Option<&Post> {
        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 len = self.items.len();
        let i = match self.state.selected() {
            Some(i) => (i + 1) % len,
            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<Posts> for Posts {
    fn as_ref(&self) -> &Self {
        self
    }
}

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