Create fs module, implement single post route

src/fs.rs

@@ -0,0 +1,64 @@
+use async_std::fs::read_to_string;
+use std::env;
+use std::ffi::OsStr;
+use std::fs::read_dir;
+use std::io::{Error, ErrorKind};
+use std::path::PathBuf;
+
+use crate::Post;
+
+pub async fn get_posts_directory_path() -> Result<PathBuf, Error> {
+    match env::var("POSTS_DIR") {
+        Ok(dir) => Ok(dir.into()),
+        Err(_) => Err(Error::new(
+            ErrorKind::Other,
+            "Posts directory environment variable not set",
+        )),
+    }
+}
+
+pub async fn get_all_posts() -> Result<Vec<Post>, Error> {
+    let mut posts: Vec<Post> = vec![];
+
+    for file in post_directory_contents().await? {
+        let file = file?;
+        if let Some("json") = file.path().extension().and_then(OsStr::to_str) {
+            let contents = read_post_from_disk(&file.path()).await?;
+            let post = Post::from_str(&contents)?;
+            posts.push(post);
+        }
+    }
+
+    Ok(posts)
+}
+
+pub async fn get_one_post(post_id: String) -> Result<Post, Error> {
+    let posts_dir = get_posts_directory_path().await?;
+    let path = posts_dir.join(format!("{}.json", post_id));
+    let contents = read_post_from_disk(&path).await?;
+    let post = Post::from_str(&contents)?;
+
+    Ok(post)
+}
+
+async fn read_post_from_disk(path: &PathBuf) -> Result<String, Error> {
+    match read_to_string(&path).await {
+        Ok(c) => Ok(c),
+        Err(_) => Err(Error::new(
+            ErrorKind::Other,
+            format!("Error reading post {:?}", &path),
+        )),
+    }
+}
+
+async fn post_directory_contents() -> Result<std::fs::ReadDir, Error> {
+    let path = get_posts_directory_path().await?;
+
+    match read_dir(path) {
+        Ok(f) => Ok(f),
+        Err(_) => Err(Error::new(
+            ErrorKind::Other,
+            "Posts directory does not exist",
+        )),
+    }
+}

src/main.rs

@@ -1,11 +1,9 @@
 use std::env;
-use std::ffi::OsStr;
-use std::fs::{read_dir, File};
+use std::fs::File;
 use std::io::prelude::*;
 use std::io::{Error, ErrorKind};
 use std::path::PathBuf;
 
-use async_std::fs::read_to_string;
 use chrono::prelude::Local;
 use dotenv;
 use serde::{Deserialize, Serialize};
@@ -15,8 +13,10 @@ use tide::utils::After;
 use tide::{Body, Response, StatusCode};
 use uuid::Uuid;
 
+mod fs;
+
 #[derive(Debug, Serialize, Deserialize)]
-struct Post {
+pub struct Post {
     id: String,
     title: String,
     body: String,
@@ -30,67 +30,26 @@ struct User {
 }
 
 impl Post {
-    fn save(&mut self) -> std::io::Result<()> {
-        let mut path: PathBuf = get_posts_directory()?;
+    async fn save(&mut self) -> std::io::Result<()> {
+        let mut path: PathBuf = fs::get_posts_directory_path().await?;
         let filename = format!("{}.json", self.id);
         path = path.join(&filename);
         let mut file = File::create(&path)?;
         file.write_all(serde_json::to_string(&self)?.as_bytes())?;
         Ok(())
     }
-}
-
-fn get_posts_directory() -> Result<PathBuf, Error> {
-    match env::var("POSTS_DIR") {
-        Ok(dir) => Ok(dir.into()),
-        Err(_) => Err(Error::new(
-            ErrorKind::Other,
-            "Posts directory environment variable not set",
-        )),
-    }
-}
 
-async fn read_all_posts() -> Result<Vec<Post>, Error> {
-    let path = match get_posts_directory() {
-        Ok(p) => Ok(p),
-        Err(_) => Err(Error::new(
-            ErrorKind::Other,
-            "POSTS_DIR variable is not set",
-        )),
-    }?;
-    let mut posts: Vec<Post> = vec![];
-
-    let files = match read_dir(path) {
-        Ok(f) => Ok(f),
-        Err(_) => Err(Error::new(
-            ErrorKind::Other,
-            "Posts directory does not exist",
-        )),
-    }?;
-
-    for file in files {
-        let file = file?;
-        if let Some("json") = file.path().extension().and_then(OsStr::to_str) {
-            let contents = match read_to_string(file.path()).await {
-                Ok(c) => Ok(c),
-                Err(_) => Err(Error::new(
-                    ErrorKind::Other,
-                    format!("Error reading post {:?}", file.path()),
-                )),
-            }?;
-            let mut post: Post = match serde_json::from_str(&contents) {
-                Ok(p) => Ok(p),
-                Err(_) => Err(Error::new(
-                    ErrorKind::Other,
-                    format!("Error deserializing post"),
-                )),
-            }?;
-            post.body = post.body.replace("\n", "<br>");
-            posts.push(post);
-        }
+    fn from_str(blob: &str) -> Result<Post, Error> {
+        let mut post: Post = match serde_json::from_str(blob) {
+            Ok(p) => Ok(p),
+            Err(_) => Err(Error::new(
+                ErrorKind::Other,
+                format!("Error deserializing post"),
+            )),
+        }?;
+        post.body = post.body.replace("\n", "<br>");
+        Ok(post)
     }
-
-    Ok(posts)
 }
 
 fn render(template: &str, context: &Context) -> Result<Body, tide::Error> {
@@ -132,7 +91,7 @@ async fn main() -> std::io::Result<()> {
     ));
 
     app.at("/").get(|req: tide::Request<()>| async move {
-        let posts = read_all_posts().await?;
+        let posts: Vec<Post> = fs::get_all_posts().await?;
         let mut context = Context::new();
         context.insert("posts", &posts);
         let logged_in: bool = req.session().get("logged_in").unwrap_or(false);
@@ -150,11 +109,22 @@ async fn main() -> std::io::Result<()> {
                 post.id = Uuid::new_v4().to_string();
                 post.date = Local::now().date().naive_local().to_string();
                 post.body = post.body.trim().to_owned();
-                post.save()?;
+                post.save().await?;
                 Ok(tide::Redirect::new("/"))
             }
         });
 
+    app.at("/posts/:id")
+        .get(|req: tide::Request<()>| async move {
+            let mut context = Context::new();
+            let logged_in: bool = req.session().get("logged_in").unwrap_or(false);
+            context.insert("logged_in", &logged_in);
+            let post_id = req.param("id")?;
+            let post = fs::get_one_post(post_id).await?;
+            context.insert("post", &post);
+            render("single.html", &context)
+        });
+
     app.at("/login")
         .get(|mut req: tide::Request<()>| async move {
             let mut context = Context::new();

templates/index.html

@@ -21,10 +21,13 @@
   {% for post in posts %}
   <div class="posts__post post">
     <h3 class="post__heading">
-      {% if logged_in %}
-      <a class="post__edit-link" href="/posts/{{ post.id }}/edit">edit</a>
-      {% endif %}
-      <span>
+      <div class="post__links">
+        <a class="post__link" href="/posts/{{ post.id }}">view</a>
+        {% if logged_in %}
+        <a class="post__link" href="/posts/{{ post.id }}/edit">edit</a>
+        {% endif %}
+      </div>
+      <span class="post__title">
         {{ post.title }} :: {{ post.date }}
       </span>
     </h3>

templates/layout.html

@@ -74,6 +74,11 @@
         padding: 0.5em;
       }
 
+      .post__title {
+        flex: 1;
+        text-align: right;
+      }
+
       .post__link {
         font-style: normal;
         font-weight: normal;

templates/single.html

@@ -0,0 +1,17 @@
+{% extends "layout.html" %} {% block content %}
+<div class="posts">
+  <div class="posts__post post">
+    <h3 class="post__heading">
+      {% if logged_in %}
+      <a class="post__link" href="/posts/{{ post.id }}/edit">edit</a>
+      {% endif %}
+      <span class="post__title">
+        {{ post.title }} :: {{ post.date }}
+      </span>
+    </h3>
+    <div class="post__body">
+      {{ post.body | safe }}
+    </div>
+  </div>
+</div>
+{% endblock %}