Add Zola migration for front matter

The front matter is defined in such a way that it can parse both the
previous and the new format that's required for Zola.

An automatic migration can be triggered with:

FIX_FRONT_MATTER=1 cargo test -p front_matter

which will be done in a separate commit.

Author: senekor

README.md

@@ -48,10 +48,14 @@ that it's something that will eventually be accepted.
 When writing a new blog post, keep in mind the file headers:
 ```md
 +++
-layout = "post"
-date = 2015-03-15
+path = "2015/03/15/some-slug"
 title = "Title of the blog post"
-author = "Blog post author (or on behalf of which team)"
+authors = ["Blog post author (or on behalf of which team)"]
+description = "(optional)"
+
+[extra] # optional section
+team = "Team Name" # if post is made on behalf of a team
+team_url = "https://www.rust-lang.org/governance/teams/..." # required if team is set
 release = true # (to be only used for official posts about Rust releases announcements)
 +++
 ```

content/_index.md

@@ -1,7 +1,8 @@
 +++
 title = "Rust Blog"
-index_title = "The Rust Programming Language Blog"
 description = "Empowering everyone to build reliable and efficient software."
+[extra]
+index_title = "The Rust Programming Language Blog"
 index_html = """
 This is the <b>main Rust blog</b>. \
 <a href="https://www.rust-lang.org/governance/">Rust teams</a> \

content/inside-rust/_index.md

@@ -1,7 +1,8 @@
 +++
 title = "Inside Rust Blog"
-index_title = 'The "Inside Rust" Blog'
 description = "Want to follow along with Rust development? Curious how you might get involved? Take a look!"
+[extra]
+index_title = 'The "Inside Rust" Blog'
 index_html = """
 This is the <b>"Inside Rust"</b> blog. This blog is aimed at those who wish \
 to follow along with Rust development. The various \

front_matter/src/lib.rs

@@ -5,14 +5,55 @@ use toml::value::Date;
 /// The front matter of a markdown blog post.
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
 pub struct FrontMatter {
-    pub layout: String,
-    pub date: Date,
+    /// Deprecated. The plan was probably to have more specialized templates
+    /// at some point. That didn't materialize, all posts are rendered with the
+    /// same template. Once we migrate to Zola, this can be achieved with the
+    /// "template" key.
+    #[serde(default, skip_serializing)]
+    pub layout: Option<String>,
+    /// Deprecated. Zola doesn't do any path templating based on things like
+    /// the date. So, in order to preserve our URL structure (YYYY/MM/DD/...)
+    /// we have to set the path explicitly. Duplicating the date would
+    /// be inconvenient for content authors who need to keep the date of
+    /// publication updated.
+    #[serde(default, skip_serializing)]
+    pub date: Option<Date>,
+    #[serde(default)]
+    pub path: String,
     pub title: String,
-    pub author: String,
+    /// Deprecated. Zola uses an "authors" key with an array instead. The front
+    /// matter tests can do the migration automatically.
+    #[serde(default, skip_serializing)]
+    pub author: Option<String>,
+    #[serde(default)]
+    pub authors: Vec<String>,
     pub description: Option<String>,
+    /// Used to generate redirects from the old URL scheme to preserve
+    /// permalinks.
+    #[serde(default)]
+    pub aliases: Vec<String>,
+    /// Moved to the `extra` table.
+    #[serde(default, skip_serializing)]
     pub team: Option<String>,
+    /// Moved to the `extra` table.
     #[serde(default, skip_serializing_if = "std::ops::Not::not")]
     pub release: bool,
+    #[serde(default, skip_serializing_if = "Extra::is_empty")]
+    pub extra: Extra,
+}
+
+#[derive(Debug, Default, PartialEq, Serialize, Deserialize)]
+pub struct Extra {
+    pub team: Option<String>,
+    pub team_url: Option<String>,
+    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+    pub release: bool,
+}
+
+impl Extra {
+    fn is_empty(&self) -> bool {
+        self.team.is_none() && !self.release
+    }
 }
 
 /// Extracts the front matter from a markdown file.
@@ -32,8 +73,42 @@ pub fn parse(markdown: &str) -> eyre::Result<(FrontMatter, &str)> {
 }
 
 /// Normalizes the front matter of a markdown file.
-pub fn normalize(markdown: &str) -> eyre::Result<String> {
-    let (front_matter, content) = parse(markdown)?;
+pub fn normalize(markdown: &str, slug: &str, inside_rust: bool) -> eyre::Result<String> {
+    let (mut front_matter, content) = parse(markdown)?;
+
+    // migrate "author" to "authors" key
+    if let Some(author) = front_matter.author.take() {
+        front_matter.authors = vec![author];
+    }
+    // migrate "team" to "extra" section
+    if let Some(team) = front_matter.team.take() {
+        let (team, url) = team.split_once(" <").unwrap();
+        let url = url.strip_suffix('>').unwrap();
+        front_matter.extra.team = Some(team.into());
+        front_matter.extra.team_url = Some(url.into());
+    }
+    // migrate "release" to "extra" section
+    if front_matter.release {
+        front_matter.release = false;
+        front_matter.extra.release = true;
+    }
+    // migrate "date" to "path" key
+    if let Some(date) = front_matter.date.take() {
+        front_matter.path = format!(
+            "{inside_rust}{year}/{month:02}/{day:02}/{slug}",
+            inside_rust = if inside_rust { "inside-rust/" } else { "" },
+            year = date.year,
+            month = date.month,
+            day = date.day,
+            // remove @ suffix, used for disambiguation only in the source
+            slug = slug.split_once('@').map(|(s, _)| s).unwrap_or(slug),
+        );
+    }
+    front_matter.aliases = vec![format!("{}.html", front_matter.path)];
+
+    if front_matter.extra.team.is_some() ^ front_matter.extra.team_url.is_some() {
+        bail!("extra.team and extra.team_url must always come in a pair");
+    }
 
     Ok(format!(
         "\
@@ -62,8 +137,16 @@ mod tests {
             .filter(|p| p.is_file() && p.file_name() != Some("_index.md".as_ref()));
 
         for post in posts {
+            let slug = post.file_stem().unwrap().to_str().unwrap();
+
+            let inside_rust = post
+                .as_os_str()
+                .to_str()
+                .unwrap()
+                .contains("content/inside-rust/");
+
             let content = fs::read_to_string(&post).unwrap();
-            let normalized = normalize(&content).unwrap_or_else(|err| {
+            let normalized = normalize(&content, slug, inside_rust).unwrap_or_else(|err| {
                 panic!("failed to normalize {:?}: {err}", post.file_name().unwrap());
             });
 
@@ -98,7 +181,7 @@ The post {post} has abnormal front matter.
     │                                                                          │
     │                You can fix this automatically by running:                │
     │                                                                          │
-    │      FIX_FRONT_MATTER=1 cargo test --all front_matter_is_normalized      │
+    │              FIX_FRONT_MATTER=1 cargo test -p front_matter               │
     │                                                                          │
     └──────────────────────────────────────────────────────────────────────────┘
 ",