use structs instead of hashmaps for templates

src/main.rs

@@ -9,13 +9,15 @@ use hotwatch::{Event, Hotwatch};
 use itertools::Itertools;
 use percent_encoding::{utf8_percent_encode, AsciiSet, CONTROLS};
 use serde::Deserialize;
-use std::collections::{BTreeMap, HashMap};
+use std::collections::HashMap;
 use std::fmt;
-use std::fs::{File, OpenOptions};
+use std::fs::{read_to_string, OpenOptions};
 use std::io::Write;
 use std::sync::{Arc, RwLock};
 use std::time::Duration;
 
+mod template_args;
+
 /// https://url.spec.whatwg.org/#fragment-percent-encode-set
 static FRAGMENT_ENCODE_SET: &AsciiSet =
   &CONTROLS.add(b' ').add(b'"').add(b'<').add(b'>').add(b'`');
@@ -75,23 +77,20 @@ fn hop(
   let data = data.read().unwrap();
 
   match resolve_hop(&query.to, &data.routes, &data.default_route) {
-    (Some(path), args) => {
-      let mut template_args = HashMap::new();
-      template_args.insert(
-        "query",
-        utf8_percent_encode(&args, FRAGMENT_ENCODE_SET).to_string(),
-      );
-
-      HttpResponse::Found()
+    (Some(path), args) => HttpResponse::Found()
       .header(
         header::LOCATION,
         data
           .renderer
-            .render_template(&path, &template_args)
+          .render_template(
+            &path,
+            &template_args::query(
+              utf8_percent_encode(&args, FRAGMENT_ENCODE_SET).to_string(),
+            ),
+          )
           .unwrap(),
       )
-        .finish()
-    }
+      .finish(),
     (None, _) => HttpResponse::NotFound().body("not found"),
   }
 }
@@ -104,7 +103,7 @@ fn hop(
 /// returns the remaining arguments. If none remain, an empty string is given.
 fn resolve_hop(
   query: &str,
-  routes: &BTreeMap<String, String>,
+  routes: &HashMap<String, String>,
   default_route: &Option<String>,
 ) -> (Option<String>, String) {
   let mut split_args = query.split_ascii_whitespace().peekable();
@@ -133,23 +132,34 @@ fn resolve_hop(
 #[get("/")]
 fn index(data: Data<Arc<RwLock<State>>>) -> impl Responder {
   let data = data.read().unwrap();
-  let mut template_args = HashMap::new();
-  template_args.insert("hostname", &data.public_address);
-  HttpResponse::Ok()
-    .body(data.renderer.render("index", &template_args).unwrap())
+  HttpResponse::Ok().body(
+    data
+      .renderer
+      .render(
+        "index",
+        &template_args::hostname(data.public_address.clone()),
+      )
+      .unwrap(),
+  )
 }
 
 #[get("/bunbunsearch.xml")]
 fn opensearch(data: Data<Arc<RwLock<State>>>) -> impl Responder {
   let data = data.read().unwrap();
-  let mut template_args = HashMap::new();
-  template_args.insert("hostname", &data.public_address);
   HttpResponse::Ok()
     .header(
       header::CONTENT_TYPE,
       "application/opensearchdescription+xml",
     )
-    .body(data.renderer.render("opensearch", &template_args).unwrap())
+    .body(
+      data
+        .renderer
+        .render(
+          "opensearch",
+          &template_args::hostname(data.public_address.clone()),
+        )
+        .unwrap(),
+    )
 }
 
 /// Dynamic variables that either need to be present at runtime, or can be
@@ -157,7 +167,7 @@ fn opensearch(data: Data<Arc<RwLock<State>>>) -> impl Responder {
 struct State {
   public_address: String,
   default_route: Option<String>,
-  routes: BTreeMap<String, String>,
+  routes: HashMap<String, String>,
   renderer: Handlebars,
 }
 
@@ -207,14 +217,14 @@ struct Config {
   bind_address: String,
   public_address: String,
   default_route: Option<String>,
-  routes: BTreeMap<String, String>,
+  routes: HashMap<String, String>,
 }
 
 /// Attempts to read the config file. If it doesn't exist, generate one a
 /// default config file before attempting to parse it.
 fn read_config(config_file_path: &str) -> Result<Config, BunBunError> {
-  let config_file = match File::open(config_file_path) {
-    Ok(file) => file,
+  let config_str = match read_to_string(config_file_path) {
+    Ok(conf_str) => conf_str,
     Err(_) => {
       eprintln!(
         "Unable to find a {} file. Creating default!",
@@ -226,10 +236,13 @@ fn read_config(config_file_path: &str) -> Result<Config, BunBunError> {
         .open(config_file_path)
         .expect("Unable to write to directory!");
       fd.write_all(DEFAULT_CONFIG)?;
-      File::open(config_file_path)?
+      String::from_utf8_lossy(DEFAULT_CONFIG).into_owned()
     }
   };
-  Ok(serde_yaml::from_reader(config_file)?)
+
+  // Reading from memory is faster than reading directly from a reader for some
+  // reason; see https://github.com/serde-rs/json/issues/160
+  Ok(serde_yaml::from_str(&config_str)?)
 }
 
 /// Returns an instance with all pre-generated templates included into the

src/template_args.rs

@@ -0,0 +1,17 @@
+use serde::Serialize;
+
+pub fn query(query: String) -> impl Serialize {
+  #[derive(Serialize)]
+  struct TemplateArgs {
+    query: String,
+  }
+  TemplateArgs { query }
+}
+
+pub fn hostname(hostname: String) -> impl Serialize {
+  #[derive(Serialize)]
+  pub struct TemplateArgs {
+    pub hostname: String,
+  }
+  TemplateArgs { hostname }
+}