git.stevedylan.dev

src/main.rs 9.6 K raw

use chrono::{DateTime, Datelike, Utc};
use color_eyre::eyre::WrapErr;
use crossterm::event::{KeyCode, KeyEvent};
use feedparser_rs::{ParsedFeed, parse_url};
use ratatui::{
    DefaultTerminal, Frame,
    layout::{Constraint, Direction, Layout},
    style::{Color, Modifier, Style},
    text::{Line, Span, Text},
    widgets::{Block, Padding, Paragraph},
};

struct Item {
    title: String,
    author: String,
    date: String,
    url: Option<String>,
    published: Option<DateTime<Utc>>,
}

fn normalize_url(s: &str) -> String {
    if s.starts_with("http://") || s.starts_with("https://") {
        s.to_string()
    } else {
        format!("https://{s}")
    }
}

fn is_bare_domain(url: &str) -> bool {
    let rest = url.split_once("://").map(|(_, r)| r).unwrap_or(url);
    rest.split_once('/')
        .map_or(true, |(_, p)| p.trim_matches('/').is_empty())
}

fn find_feed_link(html: &str, base_url: &str) -> Option<String> {
    let base = base_url.trim_end_matches('/');
    let lower = html.to_lowercase();
    let mut pos = 0;
    while let Some(tag_start) = lower[pos..].find("<link") {
        let abs = pos + tag_start;
        let tag_end = lower[abs..].find('>')? + abs;
        let tag = &html[abs..=tag_end];
        let tag_lower = tag.to_lowercase();
        let is_feed =
            tag_lower.contains("application/rss+xml") || tag_lower.contains("application/atom+xml");
        if is_feed {
            if let Some(href) = extract_attr(tag, "href") {
                let resolved = if href.starts_with("http://") || href.starts_with("https://") {
                    href
                } else if href.starts_with('/') {
                    format!("{base}{href}")
                } else {
                    format!("{base}/{href}")
                };
                return Some(resolved);
            }
        }
        pos = tag_end + 1;
    }
    None
}

fn extract_attr(tag: &str, attr: &str) -> Option<String> {
    let search = format!("{attr}=");
    let lower = tag.to_lowercase();
    let start = lower.find(&search)? + search.len();
    let rest = &tag[start..];
    let (quote, end_char) = if rest.starts_with('"') {
        (&rest[1..], '"')
    } else if rest.starts_with('\'') {
        (&rest[1..], '\'')
    } else {
        return None;
    };
    let end = quote.find(end_char)?;
    Some(quote[..end].to_string())
}

fn build_agent() -> ureq::Agent {
    ureq::Agent::config_builder()
        .timeout_global(Some(std::time::Duration::from_secs(10)))
        .build()
        .into()
}

fn discover_feed(agent: &ureq::Agent, input: &str) -> color_eyre::Result<String> {
    let url = normalize_url(input);
    if !is_bare_domain(&url) {
        return Ok(url);
    }
    let html = agent
        .get(&url)
        .call()
        .wrap_err_with(|| format!("fetch {url}"))?
        .body_mut()
        .read_to_string()
        .wrap_err_with(|| format!("read {url}"))?;
    if let Some(feed_url) = find_feed_link(&html, &url) {
        return Ok(feed_url);
    }
    let base = url.trim_end_matches('/');
    const PATHS: &[&str] = &[
        "/feed.xml",
        "/rss.xml",
        "/atom.xml",
        "/feed",
        "/rss",
        "/index.xml",
        "/feeds/posts/default",
        "/blog/feed.xml",
        "/blog/rss.xml",
    ];
    for path in PATHS {
        let candidate = format!("{base}{path}");
        if agent
            .get(&candidate)
            .call()
            .map(|r| r.status() == 200)
            .unwrap_or(false)
        {
            return Ok(candidate);
        }
    }
    Err(color_eyre::eyre::eyre!("No feed found for: {input}"))
}

fn load_feeds(urls: &[String]) -> Vec<ParsedFeed> {
    let agent = build_agent();
    urls.iter()
        .filter_map(|url| {
            let resolved = discover_feed(&agent, url)
                .map_err(|e| eprintln!("warning: skipping {url}: {e}"))
                .ok()?;
            parse_url(&resolved, None, None, None)
                .map_err(|e| eprintln!("warning: failed to parse feed {url}: {e}"))
                .ok()
        })
        .collect()
}

fn collect_items(feeds: Vec<ParsedFeed>) -> Vec<Item> {
    let mut items: Vec<Item> = feeds
        .into_iter()
        .flat_map(|f| {
            let feed_title = f.feed.title.clone();
            f.entries.into_iter().map(move |e| {
                let author = e
                    .authors
                    .first()
                    .and_then(|a| a.name.as_ref().map(|n| n.to_string()))
                    .or_else(|| feed_title.as_ref().map(|t| t.to_string()))
                    .unwrap_or_else(|| "anon".into());
                let date = e.published.map(fmt_date).unwrap_or_else(|| "-".into());
                Item {
                    title: e
                        .title
                        .map(|t| t.to_string())
                        .unwrap_or_else(|| "(untitled)".into()),
                    author,
                    date,
                    url: e.links.into_iter().next().map(|l| l.href.to_string()),
                    published: e.published,
                }
            })
        })
        .collect();
    items.sort_by(|a, b| b.published.cmp(&a.published));
    items
}

fn main() -> color_eyre::Result<()> {
    color_eyre::install()?;
    let mut urls: Vec<String> = std::env::args().skip(1).collect();
    if urls.is_empty() {
        if let Ok(val) = std::env::var("BULLETS_FEEDS") {
            urls = val
                .split(',')
                .map(|s| s.trim().to_string())
                .filter(|s| !s.is_empty())
                .collect();
        }
    }
    if urls.is_empty() {
        eprintln!("No feeds provided.\n");
        eprintln!("Usage:");
        eprintln!("  bullets <feed-url> [feed-url ...]");
        eprintln!("  bullets https://example.com/feed.xml other.com/rss");
        eprintln!("\nOr set the BULLETS_FEEDS environment variable:");
        eprintln!("  export BULLETS_FEEDS=https://example.com/feed.xml,https://other.com/rss");
        std::process::exit(1);
    }

    let feeds = load_feeds(&urls);
    if feeds.is_empty() {
        eprintln!("No feeds loaded successfully.");
        std::process::exit(1);
    }

    let items = collect_items(feeds);
    if items.is_empty() {
        eprintln!("No entries found in any feed.");
        std::process::exit(1);
    }

    ratatui::run(|t| app(t, &items))?;
    Ok(())
}

fn app(terminal: &mut DefaultTerminal, items: &[Item]) -> std::io::Result<()> {
    let mut selected = 0;
    let mut scroll_offset = 0;

    loop {
        terminal.draw(|f| render(f, items, selected, &mut scroll_offset))?;

        if let crossterm::event::Event::Key(KeyEvent { code, .. }) = crossterm::event::read()? {
            let len = items.len();
            match code {
                KeyCode::Char('q') => break,
                KeyCode::Char('j') | KeyCode::Down => {
                    selected = (selected + 1).min(len.saturating_sub(1));
                }
                KeyCode::Char('k') | KeyCode::Up => {
                    selected = selected.saturating_sub(1);
                }
                KeyCode::Enter => {
                    if let Some(url) = items[selected].url.as_deref() {
                        let _ = open::that(url);
                    }
                }
                _ => {}
            }
        }
    }

    Ok(())
}

fn fmt_date(dt: DateTime<Utc>) -> String {
    let day = dt.day();
    let suffix = match day {
        1 | 21 | 31 => "st",
        2 | 22 => "nd",
        3 | 23 => "rd",
        _ => "th",
    };
    format!("{} {}{}, {}", dt.format("%B"), day, suffix, dt.format("%Y"))
}

fn render(frame: &mut Frame, items: &[Item], selected: usize, scroll_offset: &mut u16) {
    let outer = frame.area();
    let [_, center, _] = Layout::default()
        .direction(Direction::Horizontal)
        .constraints([
            Constraint::Fill(1),
            Constraint::Max(100),
            Constraint::Fill(1),
        ])
        .areas(outer);

    let block = Block::new().padding(Padding::symmetric(2, 1));
    let inner = block.inner(center);
    let title_width = inner.width.saturating_sub(2) as usize;

    let dim = Style::new().fg(Color::DarkGray);
    let author_style = Style::new()
        .fg(Color::DarkGray)
        .add_modifier(Modifier::ITALIC);

    let mut selected_start = 0;
    let mut selected_end = 0;
    let mut lines = Vec::new();
    for (i, item) in items.iter().enumerate() {
        if i == selected {
            selected_start = lines.len();
        }

        let bar = if i == selected { "▌ " } else { "  " };
        lines.push(Line::from(vec![
            Span::raw(bar),
            Span::styled(item.date.clone(), dim),
        ]));
        for wrapped in textwrap::wrap(&item.title, title_width.max(1)) {
            lines.push(Line::from(vec![
                Span::raw(bar),
                Span::raw(wrapped.into_owned()),
            ]));
        }
        lines.push(Line::from(vec![
            Span::raw(bar),
            Span::styled(item.author.clone(), author_style),
        ]));
        lines.push(Line::from(""));

        if i == selected {
            selected_end = lines.len();
        }
    }

    let viewport_height = inner.height as usize;
    if viewport_height > 0 {
        let mut offset = *scroll_offset as usize;
        if selected_start < offset {
            offset = selected_start;
        } else if selected_end > offset + viewport_height {
            offset = selected_end.saturating_sub(viewport_height);
        }
        offset = offset.min(lines.len().saturating_sub(viewport_height));
        *scroll_offset = offset.min(u16::MAX as usize) as u16;
    }

    frame.render_widget(block, center);
    frame.render_widget(
        Paragraph::new(Text::from(lines)).scroll((*scroll_offset, 0)),
        inner,
    );
}

1	use chrono::{DateTime, Datelike, Utc};
2	use color_eyre::eyre::WrapErr;
3	use crossterm::event::{KeyCode, KeyEvent};
4	use feedparser_rs::{ParsedFeed, parse_url};
5	use ratatui::{
6	DefaultTerminal, Frame,
7	layout::{Constraint, Direction, Layout},
8	style::{Color, Modifier, Style},
9	text::{Line, Span, Text},
10	widgets::{Block, Padding, Paragraph},
11	};
12
13	struct Item {
14	title: String,
15	author: String,
16	date: String,
17	url: Option<String>,
18	published: Option<DateTime<Utc>>,
19	}
20
21	fn normalize_url(s: &str) -> String {
22	if s.starts_with("http://") \|\| s.starts_with("https://") {
23	s.to_string()
24	} else {
25	format!("https://{s}")
26	}
27	}
28
29	fn is_bare_domain(url: &str) -> bool {
30	let rest = url.split_once("://").map(\|(_, r)\| r).unwrap_or(url);
31	rest.split_once('/')
32	.map_or(true, \|(_, p)\| p.trim_matches('/').is_empty())
33	}
34
35	fn find_feed_link(html: &str, base_url: &str) -> Option<String> {
36	let base = base_url.trim_end_matches('/');
37	let lower = html.to_lowercase();
38	let mut pos = 0;
39	while let Some(tag_start) = lower[pos..].find("<link") {
40	let abs = pos + tag_start;
41	let tag_end = lower[abs..].find('>')? + abs;
42	let tag = &html[abs..=tag_end];
43	let tag_lower = tag.to_lowercase();
44	let is_feed =
45	tag_lower.contains("application/rss+xml") \|\| tag_lower.contains("application/atom+xml");
46	if is_feed {
47	if let Some(href) = extract_attr(tag, "href") {
48	let resolved = if href.starts_with("http://") \|\| href.starts_with("https://") {
49	href
50	} else if href.starts_with('/') {
51	format!("{base}{href}")
52	} else {
53	format!("{base}/{href}")
54	};
55	return Some(resolved);
56	}
57	}
58	pos = tag_end + 1;
59	}
60	None
61	}
62
63	fn extract_attr(tag: &str, attr: &str) -> Option<String> {
64	let search = format!("{attr}=");
65	let lower = tag.to_lowercase();
66	let start = lower.find(&search)? + search.len();
67	let rest = &tag[start..];
68	let (quote, end_char) = if rest.starts_with('"') {
69	(&rest[1..], '"')
70	} else if rest.starts_with('\'') {
71	(&rest[1..], '\'')
72	} else {
73	return None;
74	};
75	let end = quote.find(end_char)?;
76	Some(quote[..end].to_string())
77	}
78
79	fn build_agent() -> ureq::Agent {
80	ureq::Agent::config_builder()
81	.timeout_global(Some(std::time::Duration::from_secs(10)))
82	.build()
83	.into()
84	}
85
86	fn discover_feed(agent: &ureq::Agent, input: &str) -> color_eyre::Result<String> {
87	let url = normalize_url(input);
88	if !is_bare_domain(&url) {
89	return Ok(url);
90	}
91	let html = agent
92	.get(&url)
93	.call()
94	.wrap_err_with(\|\| format!("fetch {url}"))?
95	.body_mut()
96	.read_to_string()
97	.wrap_err_with(\|\| format!("read {url}"))?;
98	if let Some(feed_url) = find_feed_link(&html, &url) {
99	return Ok(feed_url);
100	}
101	let base = url.trim_end_matches('/');
102	const PATHS: &[&str] = &[
103	"/feed.xml",
104	"/rss.xml",
105	"/atom.xml",
106	"/feed",
107	"/rss",
108	"/index.xml",
109	"/feeds/posts/default",
110	"/blog/feed.xml",
111	"/blog/rss.xml",
112	];
113	for path in PATHS {
114	let candidate = format!("{base}{path}");
115	if agent
116	.get(&candidate)
117	.call()
118	.map(\|r\| r.status() == 200)
119	.unwrap_or(false)
120	{
121	return Ok(candidate);
122	}
123	}
124	Err(color_eyre::eyre::eyre!("No feed found for: {input}"))
125	}
126
127	fn load_feeds(urls: &[String]) -> Vec<ParsedFeed> {
128	let agent = build_agent();
129	urls.iter()
130	.filter_map(\|url\| {
131	let resolved = discover_feed(&agent, url)
132	.map_err(\|e\| eprintln!("warning: skipping {url}: {e}"))
133	.ok()?;
134	parse_url(&resolved, None, None, None)
135	.map_err(\|e\| eprintln!("warning: failed to parse feed {url}: {e}"))
136	.ok()
137	})
138	.collect()
139	}
140
141	fn collect_items(feeds: Vec<ParsedFeed>) -> Vec<Item> {
142	let mut items: Vec<Item> = feeds
143	.into_iter()
144	.flat_map(\|f\| {
145	let feed_title = f.feed.title.clone();
146	f.entries.into_iter().map(move \|e\| {
147	let author = e
148	.authors
149	.first()
150	.and_then(\|a\| a.name.as_ref().map(\|n\| n.to_string()))
151	.or_else(\|\| feed_title.as_ref().map(\|t\| t.to_string()))
152	.unwrap_or_else(\|\| "anon".into());
153	let date = e.published.map(fmt_date).unwrap_or_else(\|\| "-".into());
154	Item {
155	title: e
156	.title
157	.map(\|t\| t.to_string())
158	.unwrap_or_else(\|\| "(untitled)".into()),
159	author,
160	date,
161	url: e.links.into_iter().next().map(\|l\| l.href.to_string()),
162	published: e.published,
163	}
164	})
165	})
166	.collect();
167	items.sort_by(\|a, b\| b.published.cmp(&a.published));
168	items
169	}
170
171	fn main() -> color_eyre::Result<()> {
172	color_eyre::install()?;
173	let mut urls: Vec<String> = std::env::args().skip(1).collect();
174	if urls.is_empty() {
175	if let Ok(val) = std::env::var("BULLETS_FEEDS") {
176	urls = val
177	.split(',')
178	.map(\|s\| s.trim().to_string())
179	.filter(\|s\| !s.is_empty())
180	.collect();
181	}
182	}
183	if urls.is_empty() {
184	eprintln!("No feeds provided.\n");
185	eprintln!("Usage:");
186	eprintln!(" bullets <feed-url> [feed-url ...]");
187	eprintln!(" bullets https://example.com/feed.xml other.com/rss");
188	eprintln!("\nOr set the BULLETS_FEEDS environment variable:");
189	eprintln!(" export BULLETS_FEEDS=https://example.com/feed.xml,https://other.com/rss");
190	std::process::exit(1);
191	}
192
193	let feeds = load_feeds(&urls);
194	if feeds.is_empty() {
195	eprintln!("No feeds loaded successfully.");
196	std::process::exit(1);
197	}
198
199	let items = collect_items(feeds);
200	if items.is_empty() {
201	eprintln!("No entries found in any feed.");
202	std::process::exit(1);
203	}
204
205	ratatui::run(\|t\| app(t, &items))?;
206	Ok(())
207	}
208
209	fn app(terminal: &mut DefaultTerminal, items: &[Item]) -> std::io::Result<()> {
210	let mut selected = 0;
211	let mut scroll_offset = 0;
212
213	loop {
214	terminal.draw(\|f\| render(f, items, selected, &mut scroll_offset))?;
215
216	if let crossterm::event::Event::Key(KeyEvent { code, .. }) = crossterm::event::read()? {
217	let len = items.len();
218	match code {
219	KeyCode::Char('q') => break,
220	KeyCode::Char('j') \| KeyCode::Down => {
221	selected = (selected + 1).min(len.saturating_sub(1));
222	}
223	KeyCode::Char('k') \| KeyCode::Up => {
224	selected = selected.saturating_sub(1);
225	}
226	KeyCode::Enter => {
227	if let Some(url) = items[selected].url.as_deref() {
228	let _ = open::that(url);
229	}
230	}
231	_ => {}
232	}
233	}
234	}
235
236	Ok(())
237	}
238
239	fn fmt_date(dt: DateTime<Utc>) -> String {
240	let day = dt.day();
241	let suffix = match day {
242	1 \| 21 \| 31 => "st",
243	2 \| 22 => "nd",
244	3 \| 23 => "rd",
245	_ => "th",
246	};
247	format!("{} {}{}, {}", dt.format("%B"), day, suffix, dt.format("%Y"))
248	}
249
250	fn render(frame: &mut Frame, items: &[Item], selected: usize, scroll_offset: &mut u16) {
251	let outer = frame.area();
252	let [_, center, _] = Layout::default()
253	.direction(Direction::Horizontal)
254	.constraints([
255	Constraint::Fill(1),
256	Constraint::Max(100),
257	Constraint::Fill(1),
258	])
259	.areas(outer);
260
261	let block = Block::new().padding(Padding::symmetric(2, 1));
262	let inner = block.inner(center);
263	let title_width = inner.width.saturating_sub(2) as usize;
264
265	let dim = Style::new().fg(Color::DarkGray);
266	let author_style = Style::new()
267	.fg(Color::DarkGray)
268	.add_modifier(Modifier::ITALIC);
269
270	let mut selected_start = 0;
271	let mut selected_end = 0;
272	let mut lines = Vec::new();
273	for (i, item) in items.iter().enumerate() {
274	if i == selected {
275	selected_start = lines.len();
276	}
277
278	let bar = if i == selected { "▌ " } else { " " };
279	lines.push(Line::from(vec![
280	Span::raw(bar),
281	Span::styled(item.date.clone(), dim),
282	]));
283	for wrapped in textwrap::wrap(&item.title, title_width.max(1)) {
284	lines.push(Line::from(vec![
285	Span::raw(bar),
286	Span::raw(wrapped.into_owned()),
287	]));
288	}
289	lines.push(Line::from(vec![
290	Span::raw(bar),
291	Span::styled(item.author.clone(), author_style),
292	]));
293	lines.push(Line::from(""));
294
295	if i == selected {
296	selected_end = lines.len();
297	}
298	}
299
300	let viewport_height = inner.height as usize;
301	if viewport_height > 0 {
302	let mut offset = *scroll_offset as usize;
303	if selected_start < offset {
304	offset = selected_start;
305	} else if selected_end > offset + viewport_height {
306	offset = selected_end.saturating_sub(viewport_height);
307	}
308	offset = offset.min(lines.len().saturating_sub(viewport_height));
309	*scroll_offset = offset.min(u16::MAX as usize) as u16;
310	}
311
312	frame.render_widget(block, center);
313	frame.render_widget(
314	Paragraph::new(Text::from(lines)).scroll((*scroll_offset, 0)),
315	inner,
316	);
317	}