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

use tui::widgets::ListState;

/// Represents a response to an API request that presents a `community` field.
#[derive(Clone, Debug, PartialEq, serde::Deserialize, serde::Serialize)]
pub struct Community {
    pub id: u64,
    pub name: String,
    pub title: String,
    pub description: Option<String>,
    pub removed: bool,
    pub published: String,
    pub updated: Option<String>,
    pub deleted: bool,
    pub nsfw: bool,
    pub actor_id: String,
    pub local: bool,
    pub icon: Option<String>,
    pub hidden: bool,
    pub posting_restricted_to_mods: bool,
    pub instance_id: u64,
}

impl Community {
    /// Creates a new [Community].
    pub const fn new() -> Self {
        Self {
            id: 0,
            name: String::new(),
            title: String::new(),
            description: None,
            removed: false,
            published: String::new(),
            updated: None,
            deleted: false,
            nsfw: false,
            actor_id: String::new(),
            local: false,
            icon: None,
            hidden: false,
            posting_restricted_to_mods: false,
            instance_id: 0,
        }
    }
}

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

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

    /// Gets the list of [Community] items.
    pub fn items(&self) -> &[Community] {
        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 [Community].
    pub fn current(&self) -> Option<&Community> {
        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<Communities> for Communities {
    fn as_ref(&self) -> &Self {
        self
    }
}

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