zine/src/main.rs

extern crate chrono;
extern crate feed_rs;
extern crate maud;
extern crate reqwest;

use std::error::Error;
use std::fs::write;
use std::fs::DirBuilder;
use std::path::Path;
mod site_generator;
mod utilities;
mod web_fetchers;
use rayon::prelude::*;
use std::collections::HashMap;

fn main() -> Result<(), Box<dyn Error>> {
    simple_logger::init_with_level(log::Level::Info).unwrap();

    let mut entries = utilities::read_feed("feeds.txt");

    entries.retain(|entry| entry.score.is_positive());

    // Count occurences of main urls
    let url_counts = entries.iter().fold(HashMap::new(), |mut acc, post| {
        *acc.entry(post.main_url.clone()).or_insert(0) += 1;
        acc
    });

    // Punish blogs that post really often
    entries.iter_mut().for_each(|entry| {
        entry.score = (entry.score / url_counts.get(&entry.main_url).unwrap()) as i64;
    });

    let mut featured = utilities::read_feed("featured_feeds.txt");

    featured = featured
        .iter_mut()
        .map(|post| {
            post.score *= 1.5 as i64;
            post.clone()
        })
        .collect::<Vec<_>>();

    entries.extend(featured);

    entries.par_iter_mut().for_each(utilities::find_image);
    entries.retain(|entry| entry.score.is_positive());

    entries.sort();

    // Remove bottom 10% from list
    entries.truncate(entries.len() - (entries.len() as f64 * 0.1).ceil() as usize);

    // Make sure first entry has an image since it is used as the featured post
    let mut max_iter = 0;
    while entries.first().unwrap().image_url.is_none() {
        entries[0].score += -100;
        entries.sort();

        max_iter += 1;
        if max_iter > 10000 {
            break;
        }
    }

    let index = site_generator::generate_index(entries.clone());
    let index_path = Path::new("output/index.html");
    DirBuilder::new()
        .recursive(true)
        .create(index_path.parent().unwrap())
        .unwrap();

    match write(index_path, index.into_string()) {
        Ok(_) => log::info!("Successfully wrote to {}", index_path.display()),
        Err(e) => log::error!("Failed to write to {}: {}", index_path.display(), e),
    }

    let feed = site_generator::generate_rss(entries.clone());
    let feed_path = Path::new("output/feed.xml");
    DirBuilder::new()
        .recursive(true)
        .create(feed_path.parent().unwrap())
        .unwrap();

    match write(feed_path, feed) {
        Ok(_) => log::info!("Successfully wrote to {}", feed_path.display()),
        Err(e) => log::error!("Failed to write to {}: {}", feed_path.display(), e),
    }

    Ok(())
}