add support for multiple blogs

Author: pietroalbini

posts/blog.yml

@@ -0,0 +1,4 @@
+title: Rust Blog
+index-title: The Rust Programming Language Blog
+description: Empowering everyone to build reliable and efficient software.
+maintained-by: the Rust Team

src/blogs.rs

@@ -0,0 +1,123 @@
+use crate::posts::Post;
+use serde_derive::{Deserialize, Serialize};
+use std::error::Error;
+use std::path::{Path, PathBuf};
+
+static MANIFEST_FILE: &str = "blog.yml";
+static POSTS_EXT: &str = "md";
+
+#[derive(Deserialize)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
+struct Manifest {
+    title: String,
+    index_title: String,
+    description: String,
+    maintained_by: String,
+}
+
+#[derive(Serialize)]
+pub(crate) struct Blog {
+    title: String,
+    index_title: String,
+    description: String,
+    maintained_by: String,
+    #[serde(serialize_with = "add_postfix_slash")]
+    prefix: PathBuf,
+    posts: Vec<Post>,
+}
+
+impl Blog {
+    fn load(prefix: PathBuf, dir: &Path) -> Result<Self, Box<dyn Error>> {
+        let manifest_content = std::fs::read_to_string(dir.join(MANIFEST_FILE))?;
+        let manifest: Manifest = serde_yaml::from_str(&manifest_content)?;
+
+        let mut posts = Vec::new();
+        for entry in std::fs::read_dir(dir)? {
+            let path = entry?.path();
+            let ext = path.extension().and_then(|e| e.to_str());
+            if path.metadata()?.file_type().is_file() && ext == Some(POSTS_EXT) {
+                posts.push(Post::open(&path)?);
+            }
+        }
+
+        posts.sort_by_key(|post| post.url.clone());
+        posts.reverse();
+
+        // Decide which posts should show the year in the index.
+        posts[0].show_year = true;
+        for i in 1..posts.len() {
+            posts[i].show_year = posts[i - 1].year != posts[i].year;
+        }
+
+        Ok(Blog {
+            title: manifest.title,
+            index_title: manifest.index_title,
+            description: manifest.description,
+            maintained_by: manifest.maintained_by,
+            prefix,
+            posts,
+        })
+    }
+
+    pub(crate) fn title(&self) -> &str {
+        &self.title
+    }
+
+    pub(crate) fn index_title(&self) -> &str {
+        &self.index_title
+    }
+
+    pub(crate) fn prefix(&self) -> &Path {
+        &self.prefix
+    }
+
+    pub(crate) fn posts(&self) -> &[Post] {
+        &self.posts
+    }
+}
+
+/// Recursively load blogs in a directory. A blog is a directory with a `blog.yml`
+/// file inside it.
+pub(crate) fn load(base: &Path) -> Result<Vec<Blog>, Box<dyn Error>> {
+    let mut blogs = Vec::new();
+    load_recursive(base, base, &mut blogs)?;
+    Ok(blogs)
+}
+
+fn load_recursive(
+    base: &Path,
+    current: &Path,
+    blogs: &mut Vec<Blog>,
+) -> Result<(), Box<dyn Error>> {
+    for entry in std::fs::read_dir(current)? {
+        let path = entry?.path();
+        let file_type = path.metadata()?.file_type();
+
+        if file_type.is_dir() {
+            load_recursive(base, &path, blogs)?;
+        } else if file_type.is_file() {
+            let file_name = path.file_name().and_then(|n| n.to_str());
+            if let (Some(file_name), Some(parent)) = (file_name, path.parent()) {
+                if file_name == MANIFEST_FILE {
+                    let prefix = parent
+                        .strip_prefix(base)
+                        .map(|p| p.to_path_buf())
+                        .unwrap_or_else(|_| PathBuf::new());
+                    blogs.push(Blog::load(prefix, parent)?);
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+fn add_postfix_slash<S>(path: &PathBuf, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    let mut str_repr = path.to_string_lossy().to_string();
+    if !str_repr.is_empty() {
+        str_repr.push('/');
+    }
+    serializer.serialize_str(&str_repr)
+}

src/main.rs

@@ -1,18 +1,21 @@
+mod blogs;
 mod posts;
 
+use crate::blogs::Blog;
 use crate::posts::Post;
 use handlebars::{Context, Handlebars, Helper, HelperResult, Output, RenderContext, RenderError};
 use sass_rs::{compile_file, Options};
 use serde_derive::Serialize;
 use serde_json::json;
+use std::convert::AsRef;
 use std::error::Error;
 use std::fs::{self, File};
 use std::io::Write;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
-struct Blog {
+struct Generator {
     handlebars: Handlebars,
-    posts: Vec<Post>,
+    blogs: Vec<Blog>,
     out_directory: PathBuf,
 }
 
@@ -62,73 +65,34 @@ fn hb_month_helper<'a>(
     Ok(())
 }
 
-impl Blog {
-    fn new<T>(out_directory: T, posts_directory: T) -> Result<Blog, Box<dyn Error>>
-    where
-        T: Into<PathBuf>,
-    {
+impl Generator {
+    fn new(
+        out_directory: impl AsRef<Path>,
+        posts_directory: impl AsRef<Path>,
+    ) -> Result<Generator, Box<dyn Error>> {
         let mut handlebars = Handlebars::new();
-
         handlebars.set_strict_mode(true);
-
         handlebars.register_templates_directory(".hbs", "templates")?;
-
         handlebars.register_helper("month_name", Box::new(hb_month_helper));
 
-        let posts = Blog::load_posts(posts_directory.into())?;
-
-        Ok(Blog {
+        Ok(Generator {
             handlebars,
-            posts,
-            out_directory: out_directory.into(),
+            blogs: crate::blogs::load(posts_directory.as_ref())?,
+            out_directory: out_directory.as_ref().into(),
         })
     }
 
-    fn load_posts(dir: PathBuf) -> Result<Vec<Post>, Box<dyn Error>> {
-        let mut posts = Vec::new();
-
-        for entry in fs::read_dir(dir)? {
-            let path = entry?.path();
-
-            // ignore vim temporary files
-            let filename = path.file_name().unwrap().to_str().unwrap();
-            if filename.starts_with(".") && filename.ends_with(".swp") {
-                continue;
-            }
-
-            posts.push(Post::open(&path)?);
-        }
-
-        // finally, sort the posts. oldest first.
-        posts.sort_by_key(|post| post.url.clone());
-        posts.reverse();
-
-        for i in 1..posts.len() {
-            posts[i].show_year = posts[i - 1].year != posts[i].year;
-        }
-
-        Ok(posts)
-    }
-
     fn render(&self) -> Result<(), Box<dyn Error>> {
         // make sure our output directory exists
         fs::create_dir_all(&self.out_directory)?;
 
-        self.render_index()?;
-
-        self.render_posts()?;
-
-        self.render_feed()?;
-
+        for blog in &self.blogs {
+            self.render_blog(blog)?;
+        }
         self.compile_sass("app");
         self.compile_sass("fonts");
-
         self.concat_vendor_css(vec!["skeleton", "tachyons"]);
-
         self.copy_static_files()?;
-
-        self.generate_releases_feed()?;
-
         Ok(())
     }
 
@@ -154,70 +118,85 @@ impl Blog {
         fs::write("./static/styles/vendor.css", &concatted).expect("couldn't write vendor css");
     }
 
-    fn render_index(&self) -> Result<(), Box<dyn Error>> {
+    fn render_blog(&self, blog: &Blog) -> Result<(), Box<dyn Error>> {
+        std::fs::create_dir_all(self.out_directory.join(blog.prefix()))?;
+
+        self.render_index(blog)?;
+        self.render_feed(blog)?;
+        self.render_releases_feed(blog)?;
+        for post in blog.posts() {
+            self.render_post(blog, post)?;
+        }
+        Ok(())
+    }
+
+    fn render_index(&self, blog: &Blog) -> Result<(), Box<dyn Error>> {
         let data = json!({
-            "title": "The Rust Programming Language Blog",
+            "title": blog.index_title(),
             "parent": "layout",
-            "posts": self.posts,
+            "blog": blog,
         });
-
-        self.render_template("index.html", "index", data)?;
-
+        self.render_template(blog.prefix().join("index.html"), "index", data)?;
         Ok(())
     }
 
-    fn render_posts(&self) -> Result<(), Box<dyn Error>> {
-        for post in &self.posts {
-            // first, we create the path
-            //let path = PathBuf::from(&self.out_directory);
-
-            let path = PathBuf::from(&post.year);
-            let path = path.join(&post.month);
-            let path = path.join(&post.day);
-
-            fs::create_dir_all(self.out_directory.join(&path))?;
+    fn render_post(&self, blog: &Blog, post: &Post) -> Result<(), Box<dyn Error>> {
+        let path = blog
+            .prefix()
+            .join(&post.year)
+            .join(&post.month)
+            .join(&post.day);
+        fs::create_dir_all(self.out_directory.join(&path))?;
 
-            // then, we render the page in that path
-            let mut filename = PathBuf::from(&post.filename);
-            filename.set_extension("html");
+        // then, we render the page in that path
+        let mut filename = PathBuf::from(&post.filename);
+        filename.set_extension("html");
 
-            let data = json!({
-                "title": format!("{} | Rust Blog", post.title),
-                "parent": "layout",
-                "post": post,
-            });
-
-            self.render_template(path.join(filename).to_str().unwrap(), "post", data)?;
-        }
+        let data = json!({
+            "title": format!("{} | {}", post.title, blog.title()),
+            "parent": "layout",
+            "blog": blog,
+            "post": post,
+        });
 
+        self.render_template(path.join(filename), "post", data)?;
         Ok(())
     }
 
-    fn render_feed(&self) -> Result<(), Box<dyn Error>> {
-        let posts: Vec<_> = self.posts.iter().by_ref().take(10).collect();
-        let data =
-            json!({ "posts": posts, "feed_updated":  time::now_utc().rfc3339().to_string() });
+    fn render_feed(&self, blog: &Blog) -> Result<(), Box<dyn Error>> {
+        let posts: Vec<_> = blog.posts().iter().take(10).collect();
+        let data = json!({
+            "blog": blog,
+            "posts": posts,
+            "feed_updated": time::now_utc().rfc3339().to_string(),
+        });
 
-        self.render_template("feed.xml", "feed", data)?;
+        self.render_template(blog.prefix().join("feed.xml"), "feed", data)?;
         Ok(())
     }
 
-    fn generate_releases_feed(&self) -> Result<(), Box<dyn Error>> {
-        let posts = self.posts.clone();
+    fn render_releases_feed(&self, blog: &Blog) -> Result<(), Box<dyn Error>> {
+        let posts = blog.posts().iter().cloned().collect::<Vec<_>>();
         let is_released: Vec<&Post> = posts.iter().filter(|post| post.release).collect();
         let releases: Vec<ReleasePost> = is_released
             .iter()
             .map(|post| ReleasePost {
                 title: post.title.clone(),
-                url: post.url.clone(),
+                url: blog
+                    .prefix()
+                    .join(post.url.clone())
+                    .to_string_lossy()
+                    .to_string(),
             })
             .collect();
         let data = Releases {
             releases: releases,
             feed_updated: time::now_utc().rfc3339().to_string(),
         };
         fs::write(
-            self.out_directory.join("releases.json"),
+            self.out_directory
+                .join(blog.prefix())
+                .join("releases.json"),
             serde_json::to_string(&data)?,
         )?;
         Ok(())
@@ -239,22 +218,19 @@ impl Blog {
 
     fn render_template(
         &self,
-        name: &str,
+        name: impl AsRef<Path>,
         template: &str,
         data: serde_json::Value,
     ) -> Result<(), Box<dyn Error>> {
-        let out_file = self.out_directory.join(name);
-
+        let out_file = self.out_directory.join(name.as_ref());
         let file = File::create(out_file)?;
-
         self.handlebars.render_to_write(template, &data, file)?;
-
         Ok(())
     }
 }
 
 fn main() -> Result<(), Box<dyn Error>> {
-    let blog = Blog::new("site", "posts")?;
+    let blog = Generator::new("site", "posts")?;
 
     blog.render()?;