Separate rendering templates and writing to disk

src/main.rs

     }
 }
 
-fn render_post(cwd: &path::PathBuf, layout: &str, post_template: &str, post: &Post) {
-    let output = layout.replace(
+fn generate_post(layout: &str, post_template: &str, post: &Post) -> String {
+    layout.replace(
         "{{ contents }}",
         &post_template
             .replace("{{ title }}", &post.title)
             .replace("{{ body }}", &post.body),
-    );
+    )
+}
+
+fn render_post(cwd: &path::PathBuf, layout: &str, post_template: &str, post: &Post) {
     match fs::create_dir(cwd.join("public").join(&post.slug)) {
         Ok(_) => {}
         Err(err) => match err.kind() {
     }
     fs::write(
         cwd.join("public").join(&post.slug).join("index.html"),
-        &output,
+        generate_post(layout, post_template, post),
     ).expect("Unable to write file");
 }
 
+fn generate_post_listing(
+    layout: &str,
+    post_listing_template: &str,
+    post_item_template: &str,
+    posts: &Vec<Post>,
+) -> String {
+    layout.replace(
+        "{{ contents }}",
+        &post_listing_template.replace(
+            "{{ post_listing }}",
+            &posts
+                .iter()
+                .map(|ref post| {
+                    post_item_template
+                        .replace("{{ slug }}", &post.slug)
+                        .replace("{{ title }}", &post.title)
+                }).collect::<Vec<String>>()
+                .join("\n"),
+        ),
+    )
+}
+
 fn render_post_listing(
     cwd: &path::PathBuf,
     layout: &str,
+    post_listing_template: &str,
     post_item_template: &str,
     posts: &Vec<Post>,
 ) {
-    let post_listing_template = fs::read_to_string(cwd.join("templates").join("index.html"))
-        .expect("Couldn't read templates/index.html");
-    let post_listing = post_listing_template.replace(
-        "{{ post_listing }}",
-        &posts
-            .iter()
-            .map(|ref post| {
-                post_item_template
-                    .replace("{{ slug }}", &post.slug)
-                    .replace("{{ title }}", &post.title)
-            }).collect::<Vec<String>>()
-            .join("\n"),
-    );
-
-    let output = layout.replace("{{ contents }}", &post_listing);
-    fs::write(cwd.join("public").join("index.html"), &output).expect("Unable to write file");
+    fs::write(
+        cwd.join("public").join("index.html"),
+        generate_post_listing(layout, post_listing_template, post_item_template, posts),
+    ).expect("Unable to write file");
 }
 
 fn build() {
         .expect("Couldn't find layout template");
     let post_template = fs::read_to_string(cwd.join("templates").join("post.html"))
         .expect("Couldn't find post template");
+    let post_listing_template = fs::read_to_string(cwd.join("templates").join("post_listing.html"))
+        .expect("Couldn't find post listing item template");
     let post_item_template =
         fs::read_to_string(cwd.join("templates").join("post_listing_item.html"))
             .expect("Couldn't find post listing item template");
             Err(err) => panic!(err),
         }).collect();
 
-    render_post_listing(&cwd, &layout_template, &post_item_template, &posts);
+    render_post_listing(
+        &cwd,
+        &layout_template,
+        &post_listing_template,
+        &post_item_template,
+        &posts,
+    );
 }
 
 fn new(name: &str) {
             .expect(&format!("Couldn't create {} directory", &dir));
     }
 
-    for file in &["layout", "index", "post", "post_listing_item"] {
+    for file in &["layout", "post_listing", "post", "post_listing_item"] {
         fs::write(
             &project_path
                 .join("templates")