add _xesite_frontmatter extension

Signed-off-by: Xe Iaso <me@christine.website>

2 files changed, 74 insertions, 95 deletions

diff --git a/src/post/frontmatter.rs b/src/post/frontmatter.rs
index fa4c65c..67b96ab 100644
--- a/src/post/frontmatter.rs
+++ b/src/post/frontmatter.rs
@@ -1,26 +1,6 @@
 /// This code was borrowed from @fasterthanlime.
 use color_eyre::eyre::Result;
-use serde::{Deserialize, Serialize};
-
-#[derive(Eq, PartialEq, Deserialize, Default, Debug, Serialize, Clone)]
-pub struct Data {
-    pub title: String,
-    pub date: String,
-    pub series: Option<String>,
-    pub tags: Option<Vec<String>>,
-    pub slides_link: Option<String>,
-    pub image: Option<String>,
-    pub thumb: Option<String>,
-    pub show: Option<bool>,
-    pub redirect_to: Option<String>,
-    pub vod: Option<Vod>,
-}
-
-#[derive(Eq, PartialEq, Deserialize, Default, Debug, Serialize, Clone)]
-pub struct Vod {
-    pub twitch: String,
-    pub youtube: String,
-}
+pub use xesite_types::Frontmatter as Data;
 
 enum State {
     SearchForStart,
@@ -37,85 +17,83 @@ enum Error {
     Yaml(#[from] serde_yaml::Error),
 }
 
-impl Data {
-    pub fn parse(input: &str) -> Result<(Data, usize)> {
-        let mut state = State::SearchForStart;
+pub fn parse(input: &str) -> Result<(Data, usize)> {
+    let mut state = State::SearchForStart;
 
-        let mut payload = None;
-        let offset;
+    let mut payload = None;
+    let offset;
 
-        let mut chars = input.char_indices();
-        'parse: loop {
-            let (idx, ch) = match chars.next() {
-                Some(x) => x,
-                None => return Err(Error::EOF)?,
-            };
-            match &mut state {
-                State::SearchForStart => match ch {
-                    '-' => {
-                        state = State::ReadingMarker {
-                            count: 1,
-                            end: false,
-                        };
-                    }
-                    '\n' | '\t' | ' ' => {
-                        // ignore whitespace
+    let mut chars = input.char_indices();
+    'parse: loop {
+        let (idx, ch) = match chars.next() {
+            Some(x) => x,
+            None => return Err(Error::EOF)?,
+        };
+        match &mut state {
+            State::SearchForStart => match ch {
+                '-' => {
+                    state = State::ReadingMarker {
+                        count: 1,
+                        end: false,
+                    };
+                }
+                '\n' | '\t' | ' ' => {
+                    // ignore whitespace
+                }
+                _ => {
+                    panic!("Start of frontmatter not found");
+                }
+            },
+            State::ReadingMarker { count, end } => match ch {
+                '-' => {
+                    *count += 1;
+                    if *count == 3 {
+                        state = State::SkipNewline { end: *end };
                     }
-                    _ => {
-                        panic!("Start of frontmatter not found");
-                    }
-                },
-                State::ReadingMarker { count, end } => match ch {
-                    '-' => {
-                        *count += 1;
-                        if *count == 3 {
-                            state = State::SkipNewline { end: *end };
-                        }
-                    }
-                    _ => {
-                        panic!("Malformed frontmatter marker");
-                    }
-                },
-                State::SkipNewline { end } => match ch {
-                    '\n' => {
-                        if *end {
-                            offset = idx + 1;
-                            break 'parse;
-                        } else {
-                            state = State::ReadingFrontMatter {
-                                buf: String::new(),
-                                line_start: true,
-                            };
-                        }
-                    }
-                    _ => panic!("Expected newline, got {:?}", ch),
-                },
-                State::ReadingFrontMatter { buf, line_start } => match ch {
-                    '-' if *line_start => {
-                        let mut state_temp = State::ReadingMarker {
-                            count: 1,
-                            end: true,
+                }
+                _ => {
+                    panic!("Malformed frontmatter marker");
+                }
+            },
+            State::SkipNewline { end } => match ch {
+                '\n' => {
+                    if *end {
+                        offset = idx + 1;
+                        break 'parse;
+                    } else {
+                        state = State::ReadingFrontMatter {
+                            buf: String::new(),
+                            line_start: true,
                         };
-                        std::mem::swap(&mut state, &mut state_temp);
-                        if let State::ReadingFrontMatter { buf, .. } = state_temp {
-                            payload = Some(buf);
-                        } else {
-                            unreachable!();
-                        }
                     }
-                    ch => {
-                        buf.push(ch);
-                        *line_start = ch == '\n';
+                }
+                _ => panic!("Expected newline, got {:?}", ch),
+            },
+            State::ReadingFrontMatter { buf, line_start } => match ch {
+                '-' if *line_start => {
+                    let mut state_temp = State::ReadingMarker {
+                        count: 1,
+                        end: true,
+                    };
+                    std::mem::swap(&mut state, &mut state_temp);
+                    if let State::ReadingFrontMatter { buf, .. } = state_temp {
+                        payload = Some(buf);
+                    } else {
+                        unreachable!();
                     }
-                },
-            }
+                }
+                ch => {
+                    buf.push(ch);
+                    *line_start = ch == '\n';
+                }
+            },
         }
+    }
 
-        // unwrap justification: option set in state machine, Rust can't statically analyze it
-        let payload = payload.unwrap();
+    // unwrap justification: option set in state machine, Rust can't statically analyze it
+    let payload = payload.unwrap();
 
-        let fm: Self = serde_yaml::from_str(&payload)?;
+    let fm: Data = serde_yaml::from_str(&payload)?;
 
-        Ok((fm, offset))
-    }
+    Ok((fm, offset))
 }
diff --git a/src/post/mod.rs b/src/post/mod.rs
index f24b29c..5c2ed2d 100644
--- a/src/post/mod.rs
+++ b/src/post/mod.rs
@@ -30,7 +30,7 @@ pub struct NewPost {
 impl Into<xe_jsonfeed::Item> for Post {
     fn into(self) -> xe_jsonfeed::Item {
         let mut result = xe_jsonfeed::Item::builder()
-            .title(self.front_matter.title)
+            .title(self.front_matter.title.clone())
             .content_html(self.body_html)
             .id(format!("https://xeiaso.net/{}", self.link))
             .url(format!("https://xeiaso.net/{}", self.link))
@@ -40,7 +40,8 @@ impl Into<xe_jsonfeed::Item> for Post {
                     .name("Xe Iaso")
                     .url("https://xeiaso.net")
                     .avatar("https://xeiaso.net/static/img/avatar.png"),
-            );
+            )
+            .xesite_frontmatter(self.front_matter.clone());
 
         let mut tags: Vec<String> = vec![];
 
@@ -96,7 +97,7 @@ async fn read_post(
     let body = fs::read_to_string(fname.clone())
         .await
         .wrap_err_with(|| format!("can't read {:?}", fname))?;
-    let (front_matter, content_offset) = frontmatter::Data::parse(body.clone().as_str())
+    let (front_matter, content_offset) = frontmatter::parse(body.clone().as_str())
         .wrap_err_with(|| format!("can't parse frontmatter of {:?}", fname))?;
     let body = &body[content_offset..];
     let date = NaiveDate::parse_from_str(&front_matter.clone().date, "%Y-%m-%d")