feed-reader 0.1.3

A simple RSS/Atom feed reader for 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
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

use futures::future::join_all;

use crate::article::Article;
use crate::cache::CacheStore;
use crate::config::ExtractorMethod;
use crate::feed_source::{self, FetchResult};

use super::ArticleStore;

fn load_from_cache(
    cache: &CacheStore,
    feed_url: &str,
    feed_name: &str,
    extractor_method: &ExtractorMethod,
) -> Vec<Article> {
    cache
        .load_feed(feed_url)
        .map(|c| {
            c.articles
                .into_iter()
                .map(|info| Article {
                    title: info.title,
                    url: info.url,
                    published: info.published,
                    feed_url: feed_url.to_string(),
                    feed_name: feed_name.to_string(),
                    extractor: extractor_method.clone(),
                    read: info.read,
                    rss_content: info.rss_content,
                })
                .collect()
        })
        .unwrap_or_default()
}

impl ArticleStore {
    /// Fetch all feeds and update internal article list.
    /// If cached_only=true, only loads from cache (no network).
    pub async fn fetch(&mut self, cached_only: bool) {
        let cache_enabled = self.config().cache.retention_days >= 0;
        let default_extractor = self.config().content.extractor.clone();

        if cached_only {
            let futures: Vec<_> = self
                .feeds()
                .iter()
                .map(|feed_entry| {
                    let cache = self.cache().clone();
                    let feed_url = feed_entry.url.clone();
                    let feed_name = feed_entry.name.clone();
                    let extractor_method = feed_entry
                        .extractor
                        .as_ref()
                        .unwrap_or(&default_extractor)
                        .clone();
                    tokio::task::spawn_blocking(move || {
                        load_from_cache(&cache, &feed_url, &feed_name, &extractor_method)
                    })
                })
                .collect();

            let mut all_articles: Vec<Article> = Vec::new();
            for articles in join_all(futures).await.into_iter().flatten() {
                all_articles.extend(articles);
            }
            all_articles.sort_by(|a, b| b.published.cmp(&a.published));
            self.set_articles(all_articles);
            return;
        }

        let futures: Vec<_> = self
            .feeds()
            .iter()
            .map(|feed_entry| {
                let client = self.client().clone();
                let feed_url = feed_entry.url.clone();
                let cache = self.cache().clone();
                async move {
                    let metadata = cache.load_http_metadata(&feed_url);
                    feed_source::fetch(&client, &feed_url, &metadata).await
                }
            })
            .collect();

        let results = join_all(futures).await;

        let mut all_articles: Vec<Article> = Vec::new();

        for (feed_entry, result) in self.feeds().iter().zip(results) {
            let extractor_method = feed_entry
                .extractor
                .as_ref()
                .unwrap_or(&default_extractor)
                .clone();
            let feed_url = &feed_entry.url;
            let feed_name = &feed_entry.name;

            match result {
                Ok(FetchResult::Fetched(feed)) => {
                    if cache_enabled {
                        let save_cache = self.cache().clone();
                        let save_url = feed_url.to_string();
                        let save_feed = feed.clone();
                        let _ = tokio::task::spawn_blocking(move || {
                            save_cache.save_feed(
                                &save_url,
                                &save_feed,
                                save_feed.etag.as_deref(),
                                save_feed.last_modified.as_deref(),
                            )
                        })
                        .await;
                        all_articles.extend(load_from_cache(
                            self.cache(),
                            feed_url,
                            feed_name,
                            &extractor_method,
                        ));
                    } else {
                        all_articles.extend(feed.entries.into_iter().map(|e| Article {
                            title: e.title,
                            url: e.url,
                            published: e.published,
                            feed_url: feed_url.to_string(),
                            feed_name: feed_name.to_string(),
                            extractor: extractor_method.clone(),
                            read: false,
                            rss_content: e.rss_content,
                        }));
                    }
                }
                Ok(FetchResult::NotModified) => {
                    all_articles.extend(load_from_cache(
                        self.cache(),
                        feed_url,
                        feed_name,
                        &extractor_method,
                    ));
                }
                Err(e) => {
                    eprintln!("Error fetching {}: {}", feed_name, e);
                    all_articles.extend(load_from_cache(
                        self.cache(),
                        feed_url,
                        feed_name,
                        &extractor_method,
                    ));
                }
            }
        }

        all_articles.sort_by(|a, b| b.published.cmp(&a.published));
        self.set_articles(all_articles);
    }
}