From 40392cd6423d9956bc8227a9b83f83d00383c8ed Mon Sep 17 00:00:00 2001
From: Indigo Curnick <indigocurnick@gmail.com>
Date: Sun, 23 Jun 2024 18:56:01 +0100
Subject: [PATCH] completed the sitemap generation code, examples and
 documentation

---
 Cargo.toml                   |  2 +-
 README.md                    | 12 +++--
 examples/low/main.rs         | 31 ++++++++++--
 examples/medium/main.rs      |  3 +-
 src/common/mod.rs            |  6 +--
 src/common/types.rs          |  6 ++-
 src/high/parse.rs            |  2 -
 src/high/types.rs            | 19 +-------
 src/lib.rs                   | 29 +++++++----
 src/low/types.rs             | 93 +++++++++++++++++++++++++++--------
 src/medium/parse.rs          | 70 +--------------------------
 src/medium/types.rs          | 94 ++++++++++++++++++++++++------------
 src/sitemap/mod.rs           |  6 +++
 src/{ => sitemap}/sitemap.rs | 49 ++++---------------
 src/sitemap/types.rs         | 45 +++++++++++++++++
 src/types.rs                 | 47 +++++++++++++++++-
 tests/mod.rs                 | 14 ------
 17 files changed, 308 insertions(+), 220 deletions(-)
 create mode 100644 src/sitemap/mod.rs
 rename src/{ => sitemap}/sitemap.rs (73%)
 create mode 100644 src/sitemap/types.rs
 delete mode 100644 tests/mod.rs

diff --git a/Cargo.toml b/Cargo.toml
index 390c47c..1b39cc8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "blog-tools"
-version = "0.1.2"
+version = "0.2.0"
 edition = "2021"
 authors = ["Indigo Curnick <indigocurnick@gmail.com>"]
 description = "A collection of tools that helps make blogs in Rust"
diff --git a/README.md b/README.md
index 9537bda..a35960f 100644
--- a/README.md
+++ b/README.md
@@ -17,7 +17,7 @@ next to a `blog.json`.
 
 The JSON must conform to the following schema
 
-```rust,ignore
+```json,ignore
 {
 "title": String,
 "date": ISO 8601 Date i.e. YYYY-MM-DD,
@@ -27,7 +27,9 @@ The JSON must conform to the following schema
 "keywords": Optional<[String]>,
 "canonical_link": Optional<String>,
 "author_name": Optional<String>,
-"author_webpage": Optional<String>
+"author_webpage": Optional<String>,
+"last_modified": Optional<Date>, (ISO 8601)
+"priority": Optional<float>
 }
 ```
 
@@ -36,7 +38,6 @@ The JSON must conform to the following schema
 In `blog-tools` all slugs are /{date}/{sub-slug}.
 
 Make sure the "slug" filed in the JSON is *just* the final sub-slug
-- `blog-tools` will automatically handle the date for you
 
 ## How This Crate is Organised
 
@@ -56,7 +57,7 @@ the best way to do this is using a lazy static like so
 ```rust,ignore
 lazy_static! {
     pub static ref STATIC_BLOG_ENTRIES: HighBlog =
-        get_high_blog(PathBuf::from(BLOG_ROOT), None, None);
+        get_high_blog(PathBuf::from(BLOG_ROOT), None, None, URL, &SitemapOptions::default());
     }
 ```
 
@@ -66,7 +67,7 @@ blog posts themselves. These will need to be rendered when requested
 ```rust,ignore
 lazy_static! {
     pub static ref STATIC_BLOG_ENTRIES: MediumBlog =
-        get_medium_blog(PathBuf::from(BLOG_ROOT), None, None);
+        get_medium_blog(PathBuf::from(BLOG_ROOT), None, None, URL, &SitemapOptions::default());
     }
 
 let this_blog = match all_blogs.hash.get(&complete_slug) {
@@ -88,6 +89,7 @@ everything at runtime.
 let preview = preview_blogs(PathBuf::from_str(BLOG_ROOT).unwrap(), 2, None);
 let tags = get_blog_tag_list(PathBuf::from_str(BLOG_ROOT).unwrap());
 let blog_post = render_blog_post(PathBuf::from_str(BLOG_ROOT).unwrap(), date, slug, None).unwrap();
+let sitemap = create_sitemap(BLOG_ROOT, URL, &SitemapOptions::default());
 ```
 
 This method can have serious runtime performance implecations, but might be
diff --git a/examples/low/main.rs b/examples/low/main.rs
index e87526e..33de822 100644
--- a/examples/low/main.rs
+++ b/examples/low/main.rs
@@ -1,14 +1,17 @@
-use blog_tools::low::{
-    get_blog_tag_list, preview_blogs, preview_blogs_tagged, render_blog_post, PreviewBlogEntry,
+use blog_tools::{
+    low::{
+        get_blog_tag_list, preview_blogs, preview_blogs_tagged, render_blog_post, PreviewBlogEntry,
+    },
+    sitemap::{create_sitemap, SitemapOptions},
 };
 use rocket::{
     fs::{relative, FileServer},
-    response::Redirect,
+    response::{content::RawXml, Redirect},
     Request, Route,
 };
 use rocket_dyn_templates::Template;
 use serde::{Deserialize, Serialize};
-use std::{path::PathBuf, str::FromStr};
+use std::{fs, path::PathBuf, str::FromStr};
 
 pub static BLOG_ROOT: &str = "examples/blog";
 
@@ -82,6 +85,24 @@ fn tag_page(slug: String) -> Option<Template> {
     Some(Template::render("tags", context.into_json()))
 }
 
+pub static URL: &str = "www.example.xyz";
+
+#[get("/sitemap.xml")]
+fn sitemap() -> RawXml<String> {
+    let base_sitemap = fs::read_to_string("examples/xml/sitemap.xml").unwrap();
+    let sitemap = create_sitemap(
+        BLOG_ROOT,
+        &URL.to_string(),
+        &SitemapOptions {
+            include_tags: true,
+            sitemap_base: Some(base_sitemap),
+            ..Default::default()
+        },
+    );
+
+    return RawXml(sitemap.unwrap());
+}
+
 #[catch(404)]
 async fn not_found(req: &Request<'_>) -> Redirect {
     let mut context = rocket_dyn_templates::tera::Context::new();
@@ -97,5 +118,5 @@ async fn error(req: &Request<'_>) -> Redirect {
 }
 
 fn get_all_routes() -> Vec<Route> {
-    return routes![blog_index, blog_article, tag_page];
+    return routes![blog_index, blog_article, tag_page, sitemap];
 }
diff --git a/examples/medium/main.rs b/examples/medium/main.rs
index 0e5e9c2..40fb6b2 100644
--- a/examples/medium/main.rs
+++ b/examples/medium/main.rs
@@ -3,6 +3,7 @@ use std::{fs, path::PathBuf, str::FromStr};
 use blog_tools::{
     medium::{get_medium_blog, MediumBlog, MediumBlogEntry},
     sitemap::SitemapOptions,
+    Blog,
 };
 use lazy_static::lazy_static;
 use rocket::{
@@ -78,7 +79,7 @@ fn tag_page(slug: String) -> Option<Template> {
     let mut these_blogs: Vec<&MediumBlogEntry> = vec![];
 
     for blog in &all_blogs.entries {
-        if blog.tags.contains(&slug) {
+        if blog.get_tags().contains(&slug) {
             these_blogs.push(&blog);
         }
     }
diff --git a/src/common/mod.rs b/src/common/mod.rs
index 6a6eda7..4a5e3fb 100644
--- a/src/common/mod.rs
+++ b/src/common/mod.rs
@@ -81,19 +81,19 @@ pub fn get_json_data<T: AsRef<Path>>(blog: T) -> Result<BlogJson, BlogError> {
 
     let file_name = match blog.file_name() {
         Some(x) => x,
-        None => todo!(),
+        None => return Err(BlogError::FileNotFound),
     };
 
     let file_str = match file_name.to_str() {
         Some(x) => x,
-        None => todo!(),
+        None => return Err(BlogError::FileNotFound),
     };
 
     let name_split: Vec<&str> = file_str.split(".").collect();
 
     let n = match name_split.get(0) {
         Some(&x) => x,
-        None => todo!(),
+        None => return Err(BlogError::ImproperFileName(file_str.to_string())),
     };
 
     let name = format!("{}.json", n);
diff --git a/src/common/types.rs b/src/common/types.rs
index d00d402..bdf6343 100644
--- a/src/common/types.rs
+++ b/src/common/types.rs
@@ -17,7 +17,7 @@ pub struct BlogJson {
     pub author_name: Option<String>,
     pub author_webpage: Option<String>,
     pub last_modified: Option<NaiveDate>, // For sitemap, if not present uses `date`
-    pub priority: Option<f64>, // For sitemap, if not present uses the default 
+    pub priority: Option<f64>,            // For sitemap, if not present uses the default
 }
 
 #[derive(Debug)]
@@ -27,6 +27,7 @@ pub enum BlogError {
     FileNotFound, // TODO: It would be nice to include the file not found here but that would rely on converting a Path to a String - which involves TWO unwraps!
     /// Include the date as found as a string
     ImproperDate(String),
+    ImproperFileName(String),
 }
 
 impl Error for BlogError {}
@@ -37,7 +38,8 @@ impl Display for BlogError {
             BlogError::File(a) => write!(f, "File read error caused by: {}", a),
             BlogError::Markdown(b) => write!(f, "Markdown rendering error caused by: {}", b),
             BlogError::FileNotFound => write!(f, "File not found"),
-            BlogError::ImproperDate(c) => write!(f, "Found date `{}` which appears to be improper - dates should be in the yyyy-mm-dd format", c)
+            BlogError::ImproperDate(c) => write!(f, "Found date `{}` which appears to be improper - dates should be in the yyyy-mm-dd format", c),
+            BlogError::ImproperFileName(d) => write!(f, "Found file name `{}` which appears to be improper", d),
         }
     }
 }
diff --git a/src/high/parse.rs b/src/high/parse.rs
index ae94e6c..624c7f6 100644
--- a/src/high/parse.rs
+++ b/src/high/parse.rs
@@ -43,8 +43,6 @@ pub fn get_high_blog<T: AsRef<Path>>(
     );
 }
 
-// TODO: I will make a new function which will handle getting the list of blogs and tags, and I should use that here
-// TODO: I also wonder if using the `Blog` trait I can abstract this code even more for Medium and Low?
 fn get_blog_entries<T: AsRef<Path>>(
     base: T,
     toc_generation_func: Option<&dyn Fn(&Node) -> String>,
diff --git a/src/high/types.rs b/src/high/types.rs
index 050e7e7..041151a 100644
--- a/src/high/types.rs
+++ b/src/high/types.rs
@@ -107,22 +107,7 @@ impl Blog for HighBlogEntry {
 
         let toc = toc(&markdown, toc_generation_func)?;
 
-        return Ok(HighBlogEntry {
-            title: json.title,
-            date: json.date,
-            desc: json.desc,
-            html: html,
-            slug: json.slug,
-            tags: json.tags,
-            toc: toc,
-            keywords: json.keywords,
-            canonical_link: json.canonical_link,
-            author_name: json.author_name,
-            author_webpage: json.author_webpage,
-            preview,
-            last_modified: json.last_modified,
-            priority: json.priority,
-        });
+        return Ok(HighBlogEntry::new(json, html, toc, preview));
     }
 
     fn get_title(&self) -> String {
@@ -193,7 +178,7 @@ impl HighBlogEntry {
             date: json.date,
             desc: json.desc,
             html: html,
-            slug: format!("{}/{}", json.date, json.slug),
+            slug: json.slug,
             tags: json.tags,
             toc: toc,
             keywords: json.keywords,
diff --git a/src/lib.rs b/src/lib.rs
index e5e1573..ef8e33e 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -27,7 +27,9 @@
 //! "keywords": Optional<[String]>,
 //! "canonical_link": Optional<String>,
 //! "author_name": Optional<String>,
-//! "author_webpage": Optional<String>
+//! "author_webpage": Optional<String>,
+//! "last_modified": Optional<Date>, (ISO 8601)
+//! "priority": Optional<float>
 //! }
 //! ```
 //!
@@ -36,7 +38,6 @@
 //! In `blog-tools` all slugs are /{date}/{sub-slug}.
 //!
 //! Make sure the "slug" filed in the JSON is *just* the final sub-slug
-//! - `blog-tools` will automatically handle the date for you
 //!
 //! ## How This Crate is Organised
 //!
@@ -55,9 +56,9 @@
 //!
 //! ```rust,ignore
 //! lazy_static! {
-//!     pub static ref STATIC_BLOG_ENTRIES: HighBlog =
-//!         get_high_blog(PathBuf::from(BLOG_ROOT), None, None);
-//!     }
+//!    pub static ref STATIC_BLOG_ENTRIES: HighBlog =
+//!        get_high_blog(PathBuf::from(BLOG_ROOT), None, None, URL, &SitemapOptions::default());
+//!    }
 //! ```
 //!
 //! `medium` stores the majority of the blog, but not the rendered HTML of the
@@ -65,8 +66,8 @@
 //!
 //! ```rust,ignore
 //! lazy_static! {
-//!     pub static ref STATIC_BLOG_ENTRIES: MediumBlog =
-//!         get_medium_blog(PathBuf::from(BLOG_ROOT), None, None);
+//!    pub static ref STATIC_BLOG_ENTRIES: MediumBlog =
+//!        get_medium_blog(PathBuf::from(BLOG_ROOT), None, None, URL, &SitemapOptions::default());
 //!     }
 //!
 //! let this_blog = match all_blogs.hash.get(&complete_slug) {
@@ -88,6 +89,7 @@
 //! let preview = preview_blogs(PathBuf::from_str(BLOG_ROOT).unwrap(), 2, None);
 //! let tags = get_blog_tag_list(PathBuf::from_str(BLOG_ROOT).unwrap());
 //! let blog_post = render_blog_post(PathBuf::from_str(BLOG_ROOT).unwrap(), date, slug, None).unwrap();
+//! let sitemap = create_sitemap(BLOG_ROOT, URL, &SitemapOptions::default());
 //! ```
 //!
 //! This method can have serious runtime performance implecations, but might be
@@ -115,6 +117,12 @@ mod types;
 
 pub use types::Blog;
 
+/// Sitemap related utilities can be found here. If you use `high` or `medium`
+/// then the only thing you need from here is `SitemapOptions` to configure
+/// how a sitemap is generated.
+///
+/// If you use `low` then the function `create_sitemap` can be used to
+/// generate the sitemap
 pub mod sitemap;
 
 /// `high` refers to high RAM usage - using this module you will be effectively
@@ -124,8 +132,8 @@ pub mod sitemap;
 /// ```rust,ignore
 /// lazy_static! {
 ///     pub static ref STATIC_BLOG_ENTRIES: HighBlog =
-///         get_high_blog(PathBuf::from(BLOG_ROOT), None, None);
-///     }
+///         get_high_blog(PathBuf::from(BLOG_ROOT), None, None, URL, &SitemapOptions::default());
+/// }
 /// ```
 pub mod high;
 
@@ -139,6 +147,7 @@ pub mod high;
 /// let preview = preview_blogs(PathBuf::from_str(BLOG_ROOT).unwrap(), 2, None);
 /// let tags = get_blog_tag_list(PathBuf::from_str(BLOG_ROOT).unwrap());
 /// let blog_post = render_blog_post(PathBuf::from_str(BLOG_ROOT).unwrap(), date, slug, None).unwrap();
+/// let sitemap = create_sitemap(BLOG_ROOT, URL, &SitemapOptions::default());
 /// ```
 pub mod low;
 
@@ -149,7 +158,7 @@ pub mod low;
 /// ```rust,ignore
 /// lazy_static! {
 ///     pub static ref STATIC_BLOG_ENTRIES: MediumBlog =
-///         get_medium_blog(PathBuf::from(BLOG_ROOT), None, None);
+///         get_medium_blog(PathBuf::from(BLOG_ROOT), None, None, URL, &SitemapOptions::Default());
 ///     }
 ///
 /// let this_blog = match all_blogs.hash.get(&complete_slug) {
diff --git a/src/low/types.rs b/src/low/types.rs
index 068babe..15d464b 100644
--- a/src/low/types.rs
+++ b/src/low/types.rs
@@ -1,7 +1,13 @@
+use std::fs;
+
 use chrono::NaiveDate;
+use markdown::{to_html_with_options, Options};
 use serde::{Deserialize, Serialize};
 
-use crate::{common::BlogJson, types::Blog};
+use crate::{
+    common::{get_json_data, preview::get_preview, toc, BlogError, BlogJson},
+    types::Blog,
+};
 
 /// An individual blog post
 #[derive(Debug, Serialize, Deserialize, Clone)]
@@ -28,6 +34,9 @@ pub struct LowBlogEntry {
     pub author_name: Option<String>,
     /// Optional URL for the author
     pub author_webpage: Option<String>,
+    last_modified: Option<NaiveDate>,
+    priority: Option<f64>,
+    previw_chars: Option<usize>,
 }
 
 impl Blog for LowBlogEntry {
@@ -36,66 +45,108 @@ impl Blog for LowBlogEntry {
         toc_generation_func: Option<&dyn Fn(&markdown::mdast::Node) -> String>,
         preview_chars: Option<usize>,
     ) -> Result<Self, crate::common::BlogError> {
-        todo!();
+        let json = get_json_data(&blog)?;
+
+        let markdown = match fs::read_to_string(blog) {
+            Ok(x) => x,
+            Err(y) => return Err(BlogError::File(y)),
+        };
+
+        let html = match to_html_with_options(
+            &markdown,
+            &Options {
+                compile: markdown::CompileOptions {
+                    allow_dangerous_html: true,
+                    allow_dangerous_protocol: true,
+
+                    ..markdown::CompileOptions::default()
+                },
+                ..markdown::Options::default()
+            },
+        ) {
+            Ok(x) => x,
+            Err(y) => return Err(BlogError::Markdown(y)),
+        };
+
+        let toc = toc(&markdown, toc_generation_func)?;
+
+        return Ok(LowBlogEntry {
+            title: json.title,
+            date: json.date,
+            desc: json.desc,
+            html: html,
+            slug: json.slug,
+            tags: json.tags,
+            toc: toc,
+            keywords: json.keywords,
+            canonical_link: json.canonical_link,
+            author_name: json.author_name,
+            author_webpage: json.author_webpage,
+            last_modified: json.last_modified,
+            priority: json.priority,
+            previw_chars: preview_chars,
+        });
     }
     fn get_title(&self) -> String {
-        todo!()
+        return self.title.clone();
     }
 
     fn get_date_listed(&self) -> NaiveDate {
-        todo!()
+        return self.date.clone();
     }
 
     fn get_description(&self) -> Option<String> {
-        todo!()
+        return self.desc.clone();
     }
 
     fn get_html(&self) -> String {
-        todo!()
+        return self.html.clone();
     }
 
     fn get_full_slug(&self) -> String {
-        todo!()
+        return format!("{}/{}", self.get_date_listed(), self.get_part_slug());
     }
 
     fn get_part_slug(&self) -> String {
-        todo!()
+        return self.slug.clone();
     }
 
     fn get_tags(&self) -> Vec<String> {
-        todo!()
+        return self.tags.clone();
     }
 
     fn get_table_of_contents(&self) -> Option<String> {
-        todo!()
+        return self.toc.clone();
     }
 
     fn get_keywords(&self) -> Option<Vec<String>> {
-        todo!()
+        return self.keywords.clone();
     }
 
     fn get_canonicle_link(&self) -> Option<String> {
-        todo!()
+        return self.canonical_link.clone();
     }
 
     fn get_author_name(&self) -> Option<String> {
-        todo!()
+        return self.author_name.clone();
     }
 
     fn get_author_webpage(&self) -> Option<String> {
-        todo!()
+        return self.author_webpage.clone();
     }
 
     fn get_preview(&self) -> String {
-        todo!()
+        let preview = get_preview(&self.html, self.previw_chars);
+
+        return preview;
     }
 
     fn get_last_modified(&self) -> Option<NaiveDate> {
-        todo!()
+        return self.last_modified.clone();
     }
 
     fn get_priority(&self) -> Option<f64> {
-        todo!()
+        return self.priority.clone();
     }
 }
 
@@ -106,18 +157,20 @@ impl LowBlogEntry {
             date: json.date,
             desc: json.desc,
             html: html,
-            slug: format!("{}/{}", json.date, json.slug),
+            slug: json.slug,
             tags: json.tags,
             toc: toc,
             keywords: json.keywords,
             canonical_link: json.canonical_link,
             author_name: json.author_name,
             author_webpage: json.author_webpage,
+            last_modified: json.last_modified,
+            priority: json.priority,
+            previw_chars: None,
         };
     }
 }
 
-// TODO: What to do with this? Maybe we can implement `Blog` also?
 /// An individual blog post
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct PreviewBlogEntry {
@@ -149,7 +202,7 @@ impl PreviewBlogEntry {
             title: json.title,
             date: json.date,
             desc: json.desc,
-            slug: format!("{}/{}", json.date, json.slug),
+            slug: json.slug,
             tags: json.tags,
             keywords: json.keywords,
             canonical_link: json.canonical_link,
diff --git a/src/medium/parse.rs b/src/medium/parse.rs
index 89fc499..b5dd88b 100644
--- a/src/medium/parse.rs
+++ b/src/medium/parse.rs
@@ -1,13 +1,12 @@
 use std::{
     collections::HashMap,
-    fs,
     path::{Path, PathBuf},
 };
 
-use markdown::{mdast::Node, to_html_with_options, Options};
+use markdown::mdast::Node;
 
 use crate::{
-    common::{get_json_data, parse_blogs, preview::get_preview, toc, BlogError},
+    common::{parse_blogs, BlogError},
     sitemap::{create_sitemap_inner, SitemapOptions},
     Blog,
 };
@@ -85,68 +84,3 @@ pub fn get_blog_entries<T: AsRef<Path>>(
         sitemap: sitemap,
     });
 }
-
-fn process_blogs<T: AsRef<Path>>(
-    blog: T,
-    tags: &Vec<String>,
-    toc_generation_func: Option<&dyn Fn(&Node) -> String>,
-    preview_chars: Option<usize>,
-) -> Result<SingleBlogProcess, BlogError> {
-    let blog = blog.as_ref();
-    let json_data = get_json_data(blog)?;
-
-    let mut out_tags = vec![];
-    for tag in &json_data.tags {
-        if !tags.contains(&tag) {
-            // I guess technically, we can get repeats if the user puts the same tag in the json list...
-            out_tags.push(tag.clone());
-        }
-    }
-
-    let markdown = match fs::read_to_string(blog) {
-        Ok(x) => x,
-        Err(y) => return Err(BlogError::File(y)),
-    };
-
-    let html = match to_html_with_options(
-        &markdown,
-        &Options {
-            compile: markdown::CompileOptions {
-                allow_dangerous_html: true,
-                allow_dangerous_protocol: true,
-
-                ..markdown::CompileOptions::default()
-            },
-            ..markdown::Options::default()
-        },
-    ) {
-        Ok(x) => x,
-        Err(y) => return Err(BlogError::Markdown(y)),
-    };
-
-    let preview: String = get_preview(&html, preview_chars);
-
-    let toc = toc(&markdown, toc_generation_func)?;
-
-    let file_name = match blog.file_name() {
-        Some(x) => x,
-        None => return Err(BlogError::FileNotFound),
-    };
-
-    let file_name = match file_name.to_str() {
-        Some(x) => x.to_string(),
-        None => return Err(BlogError::FileNotFound),
-    };
-
-    let blog_entry = MediumBlogEntry::new(json_data, toc, preview, file_name);
-
-    return Ok(SingleBlogProcess {
-        blog_entry,
-        tags: out_tags,
-    });
-}
-
-struct SingleBlogProcess {
-    pub blog_entry: MediumBlogEntry,
-    pub tags: Vec<String>,
-}
diff --git a/src/medium/types.rs b/src/medium/types.rs
index 7f02726..97e025a 100644
--- a/src/medium/types.rs
+++ b/src/medium/types.rs
@@ -5,7 +5,7 @@ use markdown::{to_html_with_options, Options};
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    common::{BlogError, BlogJson},
+    common::{get_json_data, preview::get_preview, toc, BlogError, BlogJson},
     high::HighBlogEntry,
     types::Blog,
 };
@@ -43,30 +43,30 @@ pub struct MediumBlog {
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct MediumBlogEntry {
     /// Title of the blog post
-    pub title: String,
+    title: String,
     /// Date published
-    pub date: NaiveDate,
+    date: NaiveDate,
     /// Description
-    pub desc: Option<String>,
+    desc: Option<String>,
     /// The URL slug
-    pub slug: String,
+    slug: String,
     /// `Vec` of tags for this blog
-    pub tags: Vec<String>,
+    tags: Vec<String>,
     /// Table of contents
-    pub toc: Option<String>,
+    toc: Option<String>,
     /// Optional `Vec` of keywords. Intended for SEO in comparison to tags
-    pub keywords: Option<Vec<String>>,
+    keywords: Option<Vec<String>>,
     /// Optional canonical link, intended for SEO
-    pub canonical_link: Option<String>,
+    canonical_link: Option<String>,
     /// Optional author name
-    pub author_name: Option<String>,
+    author_name: Option<String>,
     /// Optional URL for the author
-    pub author_webpage: Option<String>,
+    author_webpage: Option<String>,
     /// Preview of the blogpost, useful for showing on index pages
-    pub preview: String,
+    preview: String,
     file_name: String, // ! can't be present in `high` or `low`
-    pub last_modified: Option<NaiveDate>,
-    pub priority: Option<f64>,
+    last_modified: Option<NaiveDate>,
+    priority: Option<f64>,
 }
 
 impl Blog for MediumBlogEntry {
@@ -75,67 +75,99 @@ impl Blog for MediumBlogEntry {
         toc_generation_func: Option<&dyn Fn(&markdown::mdast::Node) -> String>,
         preview_chars: Option<usize>,
     ) -> Result<Self, BlogError> {
-        todo!();
+        let json = get_json_data(&blog)?;
+
+        let markdown = match fs::read_to_string(&blog) {
+            Ok(x) => x,
+            Err(y) => return Err(BlogError::File(y)),
+        };
+
+        let html = match to_html_with_options(
+            &markdown,
+            &Options {
+                compile: markdown::CompileOptions {
+                    allow_dangerous_html: true,
+                    allow_dangerous_protocol: true,
+
+                    ..markdown::CompileOptions::default()
+                },
+                ..markdown::Options::default()
+            },
+        ) {
+            Ok(x) => x,
+            Err(y) => return Err(BlogError::Markdown(y)),
+        };
+
+        let preview: String = get_preview(&html, preview_chars);
+
+        let toc = toc(&markdown, toc_generation_func)?;
+
+        let file_name = match blog.as_ref().file_name() {
+            Some(x) => x.to_str().unwrap().to_string(),
+            None => return Err(BlogError::FileNotFound),
+        };
+
+        return Ok(MediumBlogEntry::new(json, toc, preview, file_name));
     }
 
     fn get_title(&self) -> String {
-        todo!()
+        return self.title.clone();
     }
 
     fn get_date_listed(&self) -> NaiveDate {
-        todo!()
+        return self.date.clone();
     }
 
     fn get_description(&self) -> Option<String> {
-        todo!()
+        return self.desc.clone();
     }
 
     fn get_html(&self) -> String {
-        todo!()
+        todo!();
     }
 
     fn get_full_slug(&self) -> String {
-        todo!()
+        return format!("{}/{}", self.get_date_listed(), self.get_part_slug());
     }
 
     fn get_part_slug(&self) -> String {
-        todo!()
+        return self.slug.clone();
     }
 
     fn get_tags(&self) -> Vec<String> {
-        todo!()
+        return self.tags.clone();
     }
 
     fn get_table_of_contents(&self) -> Option<String> {
-        todo!()
+        return self.toc.clone();
     }
 
     fn get_keywords(&self) -> Option<Vec<String>> {
-        todo!()
+        return self.keywords.clone();
     }
 
     fn get_canonicle_link(&self) -> Option<String> {
-        todo!()
+        return self.canonical_link.clone();
     }
 
     fn get_author_name(&self) -> Option<String> {
-        todo!()
+        return self.author_name.clone();
     }
 
     fn get_author_webpage(&self) -> Option<String> {
-        todo!()
+        return self.author_webpage.clone();
     }
 
     fn get_preview(&self) -> String {
-        todo!()
+        return self.preview.clone();
     }
 
     fn get_last_modified(&self) -> Option<NaiveDate> {
-        todo!()
+        return self.last_modified.clone();
     }
 
     fn get_priority(&self) -> Option<f64> {
-        todo!()
+        return self.priority.clone();
     }
 }
 
@@ -150,7 +182,7 @@ impl MediumBlogEntry {
             title: json.title,
             date: json.date,
             desc: json.desc,
-            slug: format!("{}/{}", json.date, json.slug),
+            slug: json.slug,
             tags: json.tags,
             toc: toc,
             keywords: json.keywords,
diff --git a/src/sitemap/mod.rs b/src/sitemap/mod.rs
new file mode 100644
index 0000000..b61cc75
--- /dev/null
+++ b/src/sitemap/mod.rs
@@ -0,0 +1,6 @@
+mod sitemap;
+mod types;
+pub use sitemap::create_sitemap;
+pub use types::SitemapOptions;
+
+pub(crate) use sitemap::create_sitemap_inner;
diff --git a/src/sitemap.rs b/src/sitemap/sitemap.rs
similarity index 73%
rename from src/sitemap.rs
rename to src/sitemap/sitemap.rs
index e8e09ff..01ddbe3 100644
--- a/src/sitemap.rs
+++ b/src/sitemap/sitemap.rs
@@ -3,51 +3,22 @@ use std::{io::Cursor, path::Path};
 use xml::{reader::XmlEvent as ReaderXmlEvent, writer::XmlEvent, EmitterConfig, EventReader};
 
 use crate::{
-    common::{get_blog_paths, get_json_data, parse_blogs, BlogError},
-    high::HighBlogEntry,
+    common::{parse_blogs, BlogError},
     low::LowBlogEntry,
     types::Blog,
 };
 
-const DATE_FORMAT: &'static str = "%d-%m-%Y";
-
-// TODO: Need to be able to pass in an already existing sitemap to append together
-
-pub struct SitemapOptions {
-    pub default_priority: f64, // default 0.5
-    pub include_tags: bool,    // default false
-    /// This represents the location of the blog in the URL. The default is
-    /// `blog`. This would mean the individual blog posts are found at
-    /// `www.example.com/blog/2024-05-12/my-blog`. If you set this parameter to
-    /// `blog-home` then the sitemap would generate
-    /// www.example.com/blog-home/2024-05/12/my-blog`
-    pub blog_root_slug: String,
-    /// This represents the location of the tag index in the URL. The default is
-    /// `blog/tag`, if you set `include_tags` to `true`. If `include_tags` is
-    /// `false` (default behaviour), then this is ignored.
-    /// For example, if you had a tag called `science` then the
-    /// URL would be `www.example.com/blog/tag/science`.
-    pub tag_root_slug: String,
-    /// Optional `String` representation of an XML sitemap. This function will
-    /// automatically merge the records of this sitemap into the sitemap it
-    /// generates. Useful if you have a bunch of pages which are not part of the
-    /// blog that you'd like in the sitemap
-    pub sitemap_base: Option<String>,
-}
+use super::types::SitemapOptions;
 
-impl Default for SitemapOptions {
-    fn default() -> Self {
-        Self {
-            default_priority: 0.5, // TODO: Maybe move this value into a constant?
-            include_tags: false,
-            blog_root_slug: "blog".to_string(), // TODO: Maybe move this value into a constant?
-            tag_root_slug: "blog/tag".to_string(),
-            sitemap_base: None,
-        }
-    }
-}
+const DATE_FORMAT: &'static str = "%d-%m-%Y";
 
-// ?: I guess this will be used in the Low module? So, I'll use a LowBlogEntry concrete type for now
+/// Use this function in `low` mode to generate a sitemap
+///
+/// Parameters
+///
+/// - `blog_root`: Path to the root of the blog e.g. `files/blog`
+/// - `url_base`: URL of the website e.g. `www.example.com`
+/// - `options`: `SitemapOptions` for configuration
 pub fn create_sitemap<T: AsRef<Path>>(
     blog_root: T,
     url_base: &String,
diff --git a/src/sitemap/types.rs b/src/sitemap/types.rs
new file mode 100644
index 0000000..9b82d3e
--- /dev/null
+++ b/src/sitemap/types.rs
@@ -0,0 +1,45 @@
+/// Options to configure how the sitemap is generated
+///
+/// `blog-tools` can generate a sitemap for all of the blogs and tags,
+/// but obviously doesn't know about any other pages. However, if you provide
+/// this struct with a String representation of an XML sitemap it will
+/// automatically add those pages into the sitemap for you
+pub struct SitemapOptions {
+    /// The default priority to use for a blog in the sitemap if no priority is
+    /// provided inside the JSON. If this is not explicityly set then the
+    /// default is 0.5
+    pub default_priority: f64,
+    /// Whether to include tag pages in the sitemap. Set this to `true` if your
+    /// website has explicit pages where all the blogs of a certain tag are
+    /// present
+    pub include_tags: bool,
+    /// This represents the location of the blog in the URL. The default is
+    /// `blog`. This would mean the individual blog posts are found at
+    /// `www.example.com/blog/2024-05-12/my-blog`. If you set this parameter to
+    /// `blog-home` then the sitemap would generate
+    /// www.example.com/blog-home/2024-05/12/my-blog`
+    pub blog_root_slug: String,
+    /// This represents the location of the tag index in the URL. The default is
+    /// `blog/tag`, if you set `include_tags` to `true`. If `include_tags` is
+    /// `false` (default behaviour), then this is ignored.
+    /// For example, if you had a tag called `science` then the
+    /// URL would be `www.example.com/blog/tag/science`.
+    pub tag_root_slug: String,
+    /// Optional `String` representation of an XML sitemap. This function will
+    /// automatically merge the records of this sitemap into the sitemap it
+    /// generates. Useful if you have a bunch of pages which are not part of the
+    /// blog that you'd like in the sitemap
+    pub sitemap_base: Option<String>,
+}
+
+impl Default for SitemapOptions {
+    fn default() -> Self {
+        Self {
+            default_priority: 0.5, // TODO: Maybe move this value into a constant?
+            include_tags: false,
+            blog_root_slug: "blog".to_string(), // TODO: Maybe move this value into a constant?
+            tag_root_slug: "blog/tag".to_string(),
+            sitemap_base: None,
+        }
+    }
+}
diff --git a/src/types.rs b/src/types.rs
index f480bb9..00983f3 100644
--- a/src/types.rs
+++ b/src/types.rs
@@ -6,25 +6,68 @@ use markdown::mdast::Node;
 use crate::common::BlogError;
 
 // TODO: give these lifetimes so we don't need to clone
+/// Primary trait that describes a single blog post. Any struct which derives
+/// this is intended to be converted into a JSON with serde and used in a template.
+/// You can of course use any of these other methods for any purpose in the
+/// blog
 pub trait Blog: Clone {
+    /// Create a blog post
+    ///
+    /// Parameters
+    ///
+    /// - `blog`: Path to the root of the blog
+    ///     For this to work, you should have a folder, for instance, `blog` which serves
+    ///     as the root. Within this folder, you must have the following structure
+    ///
+    ///     - blog
+    ///         - 2023
+    ///             - 2023-01-01
+    ///                 - my_first_blog.json
+    ///                 - my_first_blog.md
+    ///             - (other folders)
+    ///
+    /// - `toc_generation_func` - A function which parses a blog and generates
+    ///     a table of contents. Optional.
+    /// - `preview_chars` - number of chars to be taken in the preview of the
+    ///     blog. Default is 320.
     fn create<T: AsRef<Path>>(
         blog: T,
         toc_generation_func: Option<&dyn Fn(&Node) -> String>,
         preview_chars: Option<usize>,
     ) -> Result<Self, BlogError>;
+    /// Get the blog title
     fn get_title(&self) -> String;
+    /// Get the original publication date
     fn get_date_listed(&self) -> NaiveDate;
+    /// Get the SEO description
     fn get_description(&self) -> Option<String>;
+    /// Get the HTML of the blog
     fn get_html(&self) -> String;
-    fn get_full_slug(&self) -> String; // This would be `2024-03-19/my-blog`
-    fn get_part_slug(&self) -> String; // This would be `my-blog`
+    /// Get the full slug - this would be e.g. `2024-03-19/my-blog`.
+    /// In the JSON, you should NOT include the date in the slug
+    fn get_full_slug(&self) -> String;
+    /// Get the partial slug of the blog. This would be the `slug` field from the
+    /// JSON
+    fn get_part_slug(&self) -> String;
+    /// Get a list of tags for the blog
     fn get_tags(&self) -> Vec<String>;
+    /// Get the table of contents. Only present if a table of contents funciton
+    /// was provided
     fn get_table_of_contents(&self) -> Option<String>;
+    /// Get keywords
     fn get_keywords(&self) -> Option<Vec<String>>;
+    /// Get the canonicle link
     fn get_canonicle_link(&self) -> Option<String>;
+    /// Get the author
     fn get_author_name(&self) -> Option<String>; // TODO: Maybe support authors?
+    /// Get the author webpage
     fn get_author_webpage(&self) -> Option<String>; // TODO: again, support multiple authors?
+    /// Get the blog preview. This is the first few hundred characters of the blog,
+    /// useful for an index page
     fn get_preview(&self) -> String;
+    /// Get the last modified date, mostly use for sitemaps. This is not the
+    /// original publication date
     fn get_last_modified(&self) -> Option<NaiveDate>;
+    /// Get the priority for the sitemap
     fn get_priority(&self) -> Option<f64>;
 }
diff --git a/tests/mod.rs b/tests/mod.rs
deleted file mode 100644
index 0c5192a..0000000
--- a/tests/mod.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-use std::{path::PathBuf, str::FromStr};
-
-use blog_tools::sitemap::generate_sitemap;
-
-extern crate blog_tools;
-
-#[test]
-fn test_sitemap() {
-    let path = PathBuf::from_str("examples/blog").unwrap();
-    let base = "www.example.com".to_string();
-    let sitemap = generate_sitemap(path, &base, None, false);
-
-    println!("{}", sitemap);
-}