agadir 0.1.0

Blogging over the terminal
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

use std::error;

use chrono::NaiveDate;
use ratatui::{
    layout::{Alignment, Constraint, Direction, Layout},
    style::{Color, Style, Stylize},
    text::Text,
    widgets::{Block, Clear, Padding, Paragraph, Row, Table, TableState, Wrap},
    Frame,
};

use crate::post::Post;

pub type AppResult<T> = std::result::Result<T, Box<dyn error::Error>>;

#[derive(Debug, Clone, PartialEq)]
pub enum FocusedBlock {
    Toc,
    Post,
}

pub struct App<'a> {
    pub running: bool,
    pub focused_block: FocusedBlock,
    pub posts: Vec<Post<'a>>,
    pub scroll: u16,
    pub toc: Vec<(NaiveDate, Text<'a>)>,
    pub toc_state: TableState,
    pub area_height: u16,
    pub previous_key: Vec<u8>,
}

impl<'a> App<'a> {
    pub fn new(posts: Vec<Post<'a>>, toc: Vec<(NaiveDate, Text<'a>)>) -> Self {
        let mut toc_state = TableState::default();
        if toc.is_empty() {
            toc_state.select(None);
        } else {
            toc_state.select(Some(0));
        }

        let focused_block = FocusedBlock::Toc;
        let scroll: u16 = 0;

        let area_height = 0;

        Self {
            running: true,
            focused_block,
            posts,
            scroll,
            toc,
            toc_state,
            area_height,
            previous_key: vec![0],
        }
    }

    pub fn render(&self, frame: &mut Frame) {
        match self.focused_block {
            FocusedBlock::Toc => {
                let layout = Layout::default()
                    .direction(Direction::Vertical)
                    .constraints(
                        [
                            Constraint::Percentage(20),
                            Constraint::Min(self.toc.len() as u16 + 2),
                            Constraint::Percentage(20),
                        ]
                        .as_ref(),
                    )
                    .split(frame.size());

                let block = Layout::default()
                    .direction(Direction::Horizontal)
                    .constraints(
                        [
                            Constraint::Percentage(20),
                            Constraint::Fill(1),
                            Constraint::Percentage(20),
                        ]
                        .as_ref(),
                    )
                    .split(layout[1])[1];

                let widths = [Constraint::Length(20), Constraint::Fill(1)];
                let rows: Vec<Row> = self
                    .toc
                    .iter()
                    .map(|key| {
                        let date = key.0.format("%B %d %Y").to_string();
                        let title = key.1.to_string();
                        Row::new(vec![date, title]).style(Style::default().fg(Color::White))
                    })
                    .collect();

                let table = Table::new(rows, widths)
                    .block(
                        Block::default()
                            .title("Posts")
                            .title_style(Style::default().bold().fg(Color::Green))
                            .title_alignment(Alignment::Center)
                            .padding(Padding::top(2))
                            .style(Style::default()),
                    )
                    .highlight_symbol(Text::from(">>  ").style(Style::new().yellow().bold()));

                frame.render_widget(Clear, block);
                frame.render_stateful_widget(table, block, &mut self.toc_state.clone());
            }

            FocusedBlock::Post => {
                if let Some(i) = self.toc_state.selected() {
                    let post_title = &self.toc[i].1;

                    if let Some(post) = self.posts.iter().find(|p| &p.title == post_title) {
                        let paragraph = Paragraph::new(post.content.clone())
                            .wrap(Wrap { trim: false })
                            .block(Block::new().title_alignment(Alignment::Center))
                            .style(Style::default())
                            .scroll((self.scroll, 0));

                        frame.render_widget(paragraph, frame.size());
                    }
                };
            }
        }
    }
}