fido 0.2.3

A blazing-fast, keyboard-driven social platform for developers
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

use ratatui::{
    style::{Modifier, Style},
    text::{Line, Span},
};

use super::theme::ThemeColors;

// Layout constants
pub const BORDER_PADDING: u16 = 4; // Total horizontal padding from borders (2 per side)

/// Format timestamp for display
pub fn format_timestamp(timestamp: &chrono::DateTime<chrono::Utc>) -> String {
    timestamp.format("%Y-%m-%d %H:%M").to_string()
}

/// Format post content with hashtag highlighting and text wrapping
#[allow(dead_code)]
pub fn format_post_content(
    content: &str,
    is_selected: bool,
    theme: &ThemeColors,
) -> Vec<Line<'static>> {
    format_post_content_with_width(content, is_selected, theme, 80)
}

/// Format post content with hashtag highlighting and text wrapping with specified width
pub fn format_post_content_with_width(
    content: &str,
    is_selected: bool,
    theme: &ThemeColors,
    max_width: usize,
) -> Vec<Line<'static>> {
    let mut lines = vec![];
    let wrap_width = max_width.saturating_sub(4);

    for line in content.lines() {
        let wrapped = textwrap::wrap(line, wrap_width);

        for wrapped_line in wrapped {
            let mut spans = vec![Span::raw("  ")]; // Indent

            let line_str = wrapped_line.to_string();
            let mut current_word = String::new();
            let mut whitespace_buffer = String::new();

            for ch in line_str.chars() {
                if ch.is_whitespace() {
                    if !current_word.is_empty() {
                        push_styled_word(&mut spans, &current_word, is_selected, theme);
                        current_word.clear();
                    }
                    whitespace_buffer.push(ch);
                } else {
                    if !whitespace_buffer.is_empty() {
                        spans.push(Span::raw(std::mem::take(&mut whitespace_buffer)));
                    }
                    current_word.push(ch);
                }
            }

            if !current_word.is_empty() {
                push_styled_word(&mut spans, &current_word, is_selected, theme);
            }
            if !whitespace_buffer.is_empty() {
                spans.push(Span::raw(whitespace_buffer));
            }

            lines.push(Line::from(spans));
        }
    }

    lines
}

/// Push a styled word to spans with appropriate formatting
fn push_styled_word(
    spans: &mut Vec<Span<'static>>,
    word: &str,
    is_selected: bool,
    theme: &ThemeColors,
) {
    let (color, should_bold) = if word.starts_with('#') {
        (
            if is_selected {
                theme.accent
            } else {
                theme.secondary
            },
            true,
        )
    } else if word.starts_with('@') {
        (theme.primary, true)
    } else {
        (theme.text, is_selected)
    };

    let mut style = Style::default().fg(color);
    if should_bold {
        style = style.add_modifier(Modifier::BOLD);
    }

    spans.push(Span::styled(word.to_string(), style));
}

/// Format post content for input box (no indent, simpler formatting)
#[allow(dead_code)]
pub fn format_post_content_for_input(content: &str) -> Vec<Line<'static>> {
    content
        .lines()
        .map(|line| Line::from(line.to_string()))
        .collect()
}

/// Format bio content with wrapping
#[allow(dead_code)]
pub fn format_bio_content_with_width(
    content: &str,
    max_width: usize,
    theme: &ThemeColors,
) -> Vec<Line<'static>> {
    let mut lines = vec![];

    for line in content.lines() {
        let wrapped = textwrap::wrap(line, max_width);
        for wrapped_line in wrapped {
            lines.push(Line::from(Span::styled(
                wrapped_line.to_string(),
                Style::default().fg(theme.text),
            )));
        }
    }

    if lines.is_empty() {
        lines.push(Line::from(""));
    }

    lines
}