Make updated time unique

I split published, and updated time, and made it so duplicate updated times get different seconds.

Author: Zexbe

src/blogs.rs

@@ -68,6 +68,16 @@ impl Blog {
             posts[i].show_year = posts[i - 1].year != posts[i].year;
         }
 
+        // Make the updated time is unique, by incrementing seconds for duplicates
+        let mut last_matching_updated = 0;
+        for i in 1..posts.len() {
+            if posts[i].updated == posts[last_matching_updated].updated {
+                posts[i].set_updated((i - last_matching_updated) as u32);
+            } else {
+                last_matching_updated = i;
+            }
+        }
+
         Ok(Blog {
             title: manifest.title,
             index_title: manifest.index_title,

src/main.rs

@@ -3,7 +3,7 @@ mod posts;
 
 use crate::blogs::Blog;
 use crate::posts::Post;
-use handlebars::{Context, Handlebars, Helper, HelperResult, Output, RenderContext, RenderError};
+use handlebars::{handlebars_helper, Handlebars};
 use sass_rs::{compile_file, Options};
 use serde_derive::Serialize;
 use serde_json::json;
@@ -30,40 +30,21 @@ struct ReleasePost {
     title: String,
     url: String,
 }
-
-fn hb_month_helper<'a>(
-    h: &Helper,
-    _b: &Handlebars,
-    _ctx: &Context,
-    _rc: &mut RenderContext,
-    out: &mut dyn Output,
-) -> HelperResult {
-    let num: u32 = h
-        .param(0)
-        .unwrap()
-        .value()
-        .as_str()
-        .unwrap()
-        .parse()
-        .or_else(|_| Err(RenderError::new("The value is not a number")))?;
-    let name = match num {
-        1 => "Jan.",
-        2 => "Feb.",
-        3 => "Mar.",
-        4 => "Apr.",
-        5 => "May",
-        6 => "June",
-        7 => "July",
-        8 => "Aug.",
-        9 => "Sept.",
-        10 => "Oct.",
-        11 => "Nov.",
-        12 => "Dec.",
-        _ => "Error!",
-    };
-    out.write(name)?;
-    Ok(())
-}
+handlebars_helper!(hb_month_name_helper: |month_num: u64| match month_num {
+    1 => "Jan.",
+    2 => "Feb.",
+    3 => "Mar.",
+    4 => "Apr.",
+    5 => "May",
+    6 => "June",
+    7 => "July",
+    8 => "Aug.",
+    9 => "Sept.",
+    10 => "Oct.",
+    11 => "Nov.",
+    12 => "Dec.",
+    _ => "Error!",
+});
 
 impl Generator {
     fn new(
@@ -73,7 +54,7 @@ impl Generator {
         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));
+        handlebars.register_helper("month_name", Box::new(hb_month_name_helper));
 
         Ok(Generator {
             handlebars,
@@ -131,11 +112,16 @@ impl Generator {
     }
 
     fn render_index(&self, blog: &Blog) -> Result<(), Box<dyn Error>> {
-        let other_blogs: Vec<_> = self.blogs.iter().filter(|b| b.index_title() != blog.index_title())
-            .map(|other_blog| json!({
-                "link_text": other_blog.link_text(),
-                "url": PathBuf::from("/").join(other_blog.prefix()).join("index.html"),
-            }))
+        let other_blogs: Vec<_> = self
+            .blogs
+            .iter()
+            .filter(|b| b.index_title() != blog.index_title())
+            .map(|other_blog| {
+                json!({
+                    "link_text": other_blog.link_text(),
+                    "url": PathBuf::from("/").join(other_blog.prefix()).join("index.html"),
+                })
+            })
             .collect();
 
         let data = json!({
@@ -151,9 +137,9 @@ impl Generator {
     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);
+            .join(&post.year.to_string())
+            .join(&post.month.to_string())
+            .join(&post.day.to_string());
         fs::create_dir_all(self.out_directory.join(&path))?;
 
         // then, we render the page in that path
@@ -202,9 +188,7 @@ impl Generator {
             feed_updated: time::now_utc().rfc3339().to_string(),
         };
         fs::write(
-            self.out_directory
-                .join(blog.prefix())
-                .join("releases.json"),
+            self.out_directory.join(blog.prefix()).join("releases.json"),
             serde_json::to_string(&data)?,
         )?;
         Ok(())

src/posts.rs

@@ -4,6 +4,7 @@ use regex::Regex;
 use serde_derive::{Deserialize, Serialize};
 use std::error::Error;
 use std::path::{Path, PathBuf};
+use time::{Duration, Tm};
 
 #[derive(Debug, PartialEq, Deserialize)]
 struct YamlHeader {
@@ -21,13 +22,14 @@ pub(crate) struct Post {
     pub(crate) layout: String,
     pub(crate) title: String,
     pub(crate) author: String,
-    pub(crate) year: String,
+    pub(crate) year: u32,
     pub(crate) show_year: bool,
-    pub(crate) month: String,
-    pub(crate) day: String,
+    pub(crate) month: u32,
+    pub(crate) day: u32,
     pub(crate) contents: String,
     pub(crate) url: String,
     pub(crate) published: String,
+    pub(crate) updated: String,
     pub(crate) release: bool,
     pub(crate) has_team: bool,
     pub(crate) team: String,
@@ -42,9 +44,10 @@ impl Post {
         // we need to get the metadata out of the url
         let mut split = filename.splitn(4, "-");
 
-        let year = split.next().unwrap().to_string();
-        let month = split.next().unwrap().to_string();
-        let day = split.next().unwrap().to_string();
+        // we do some unwraps because these need to be valid
+        let year = split.next().unwrap().parse::<u32>().unwrap();
+        let month = split.next().unwrap().parse::<u32>().unwrap();
+        let day = split.next().unwrap().parse::<u32>().unwrap();
         let filename = split.next().unwrap().to_string();
 
         let contents = std::fs::read_to_string(path)?;
@@ -76,29 +79,16 @@ impl Post {
         // this is fine
         let url = format!("{}/{}/{}/{}", year, month, day, url.to_str().unwrap());
 
-        // build the published time. this is only approximate, which is fine.
-        // we do some unwraps because these need to be valid
-        let published = time::Tm {
-            tm_sec: 0,
-            tm_min: 0,
-            tm_hour: 0,
-            tm_mday: day.parse::<i32>().unwrap(),
-            tm_mon: month.parse::<i32>().unwrap() - 1, // 0-11 not 1-12
-            tm_year: year.parse::<i32>().unwrap() - 1900, // from the year 1900, not the actual year
-            // these next two fields are wrong but we never use them to generate our times
-            tm_wday: 1,
-            tm_yday: 1,
-            tm_isdst: 0,
-            tm_utcoff: 0,
-            tm_nsec: 0,
-        };
-
-        let published = published.rfc3339().to_string();
+        let published = build_post_time(year, month, day, 0);
+        let updated = published.clone();
 
         // validate for now that the layout is specified as "post"
         match &*layout {
             "post" => (),
-            _ => panic!("blog post at path `{}` should have layout `post`", path.display()),
+            _ => panic!(
+                "blog post at path `{}` should have layout `post`",
+                path.display()
+            ),
         };
 
         // Enforce extra conditions
@@ -114,13 +104,18 @@ impl Post {
                 }
                 let captures = match R.captures(&s) {
                     Some(c) => c,
-                    None => panic!("team from path `{}` should have format `$name <$url>`",
-                                   path.display()),
+                    None => panic!(
+                        "team from path `{}` should have format `$name <$url>`",
+                        path.display()
+                    ),
                 };
-                (Some(captures["name"].to_string()), Some(captures["url"].to_string()))
+                (
+                    Some(captures["name"].to_string()),
+                    Some(captures["url"].to_string()),
+                )
             }
 
-            None => (None, None)
+            None => (None, None),
         };
 
         Ok(Self {
@@ -134,11 +129,36 @@ impl Post {
             contents,
             url,
             published,
+            updated,
             release,
             layout,
             has_team: team.is_some(),
             team: team.unwrap_or_default(),
             team_url: team_url.unwrap_or_default(),
         })
     }
+
+    pub fn set_updated(&mut self, hour: u32) {
+        self.updated = build_post_time(self.year, self.month, self.day, hour);
+    }
+}
+
+fn build_post_time(year: u32, month: u32, day: u32, seconds: u32) -> String {
+    // build the time. this is only approximate, which is fine.
+    let mut time = Tm {
+        tm_sec: 0,
+        tm_min: 0,
+        tm_hour: 0,
+        tm_mday: day as i32,
+        tm_mon: (month as i32) - 1,    // 0-11 not 1-12
+        tm_year: (year as i32) - 1900, // from the year 1900, not the actual year
+        // these next two fields are wrong but we never use them to generate our times
+        tm_wday: 1,
+        tm_yday: 1,
+        tm_isdst: 0,
+        tm_utcoff: 0,
+        tm_nsec: 0,
+    };
+    time = time + Duration::seconds(seconds as i64);
+    time.rfc3339().to_string()
 }

templates/feed.hbs

@@ -17,7 +17,7 @@
         <title>{{title}}</title>
         <link rel="alternate" href="https://blog.rust-lang.org/{{../blog.prefix}}{{url}}" type="text/html" title="{{title}}" />
         <published>{{published}}</published>
-        <updated>{{published}}</updated>
+        <updated>{{updated}}</updated>
         <id>https://blog.rust-lang.org/{{../blog.prefix}}{{url}}</id>
         <content type="html" xml:base="https://blog.rust-lang.org/{{../blog.prefix}}{{url}}">{{contents}}</content>