refactor modules

axum_server/src/post_utils/mod.rs

@@ -0,0 +1,2 @@
+pub mod post_listing;
+pub mod post_parser;

axum_server/src/post_utils/post_listing.rs

@@ -0,0 +1,40 @@
+use axum::http::StatusCode;
+use serde::de::DeserializeOwned;
+use tokio::fs::read_dir;
+use tracing::info;
+
+use super::post_parser::{parse_post, ParseResult};
+
+pub async fn get_post_list<'de, Metadata: DeserializeOwned>(
+    path: &str,
+) -> Result<Vec<ParseResult<Metadata>>, StatusCode> {
+    // let path = "../_posts/blog/";
+    let mut dir = read_dir(path)
+        .await
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+    let mut posts: Vec<ParseResult<Metadata>> = Vec::new();
+
+    while let Some(file) = dir
+        .next_entry()
+        .await
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?
+    {
+        let file_path = file.path();
+        let file_path_str = file_path.to_str().unwrap();
+        info!(":{}", file_path_str);
+        let post = parse_post::<Metadata>(file_path_str).await?;
+        posts.push(post);
+    }
+
+    if std::env::var("TARGET")
+        .unwrap_or_else(|_| "DEV".to_owned())
+        .eq("PROD")
+    {
+        posts = posts
+            .into_iter()
+            .filter(|post| !post.slug.starts_with("dev"))
+            .collect()
+    }
+
+    return Ok(posts);
+}

axum_server/src/post_utils/post_parser.rs

@@ -0,0 +1,112 @@
+use std::path::Path;
+
+use axum::http::StatusCode;
+use chrono::{DateTime, Utc};
+use gray_matter::{engine::YAML, Matter};
+use pulldown_cmark::{Event, Options, Parser, Tag, TagEnd};
+use serde::{de::DeserializeOwned, Deserialize, Deserializer};
+use tokio::fs;
+
+pub fn deserialize_date<'de, D>(deserializer: D) -> Result<DateTime<Utc>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let date_str = String::deserialize(deserializer)?;
+    match DateTime::parse_from_rfc3339(&date_str) {
+        Ok(datetime) => Ok(datetime.with_timezone(&Utc)),
+        Err(err) => Err(serde::de::Error::custom(format!(
+            "Error parsing date: {}",
+            err
+        ))),
+    }
+}
+
+pub struct ParseResult<Metadata> {
+    pub body: String,
+    pub metadata: Metadata,
+    pub slug: String,
+}
+
+pub async fn parse_post<'de, Metadata: DeserializeOwned>(
+    path: &str,
+) -> Result<ParseResult<Metadata>, StatusCode> {
+    let file_contents = fs::read_to_string(path)
+        .await
+        // TODO Proper reasoning for an error
+        .map_err(|_| StatusCode::NOT_FOUND)?;
+
+    let matter = Matter::<YAML>::new();
+    let metadata = matter
+        .parse_with_struct::<Metadata>(&file_contents)
+        .ok_or_else(|| {
+            tracing::error!("Failed to parse metadata");
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?;
+
+    let body = parse_html(&metadata.content);
+
+    let filename = Path::new(path)
+        .file_stem()
+        .ok_or(StatusCode::INTERNAL_SERVER_ERROR)?
+        .to_str()
+        .ok_or(StatusCode::INTERNAL_SERVER_ERROR)?
+        .to_owned();
+
+    Ok(ParseResult {
+        body,
+        metadata: metadata.data,
+        slug: filename,
+    })
+}
+
+pub fn parse_html(markdown: &str) -> String {
+    let mut options = Options::empty();
+    options.insert(Options::ENABLE_TABLES);
+    options.insert(Options::ENABLE_FOOTNOTES);
+    options.insert(Options::ENABLE_STRIKETHROUGH);
+    options.insert(Options::ENABLE_TASKLISTS);
+    options.insert(Options::ENABLE_SMART_PUNCTUATION);
+    options.insert(Options::ENABLE_HEADING_ATTRIBUTES);
+
+    let parser = Parser::new_ext(markdown, options).map(|event| match event {
+        /*
+        Parsing images considers `alt` attribute as inner `Text` event
+        Therefore the `[alt]` is rendered in html as subtitle
+        and the `[](url "title")` `title` is rendered as `alt` attribute
+        */
+        Event::Start(Tag::Image {
+            link_type,
+            dest_url,
+            title,
+            id,
+        }) => {
+            println!(
+                "Image link_type: {:?} url: {} title: {} id: {}",
+                link_type, dest_url, title, id
+            );
+            // TODO src set
+            Event::Html(
+                format!(
+                    r#"<figure>
+                            <img
+                              alt="{alt}"
+                              src="{src}"
+                            />
+                            <figcaption>
+                        "#,
+                    alt = title,
+                    src = dest_url,
+                )
+                .into(),
+            )
+        }
+        Event::Start(_) => event,
+        Event::End(TagEnd::Image) => Event::Html("</figcaption></figure>".into()),
+        _ => event,
+    });
+
+    // Write to String buffer
+    let mut html = String::new();
+    pulldown_cmark::html::push_html(&mut html, parser);
+    html
+}