code cleanup

src/config.rs

@@ -60,16 +60,16 @@ pub fn get_path(xdg: &str) -> Result<String, (String, u32)> {
   
   if unsafe { libc::geteuid() } == 0 {
     dir = match xdg {
-      "XDG_CACHE_HOME" => "/var/cms".to_owned(),
+      "XDG_CACHE_HOME" => "/var".to_owned(),
-      "XDG_CONFIG_HOME" => "/etc/cms".to_owned(),
+      "XDG_CONFIG_HOME" => "/etc".to_owned(),
       _ => panic!("nya"),
     };
   } else {
     dir = match env::var(xdg) {
-      Ok(val) => val,
+      Ok(var) => var,
       Err(_) => {
         match env::var("HOME") {
-          Ok(home) => format!("{}/.config/", home),
+          Ok(home) => format!("{}/.config", home),
           Err(_) => {
             return Err((
               "Unable to determine path to current user’s home directory."
@@ -81,11 +81,8 @@ pub fn get_path(xdg: &str) -> Result<String, (String, u32)> {
       },
     };
   }
-  match xdg {
+
-    "XDG_CACHE_HOME" => Ok(format!("{}/cms", dir)),
+  Ok(format!("{}/plaque", dir))
-    "XDG_CONFIG_HOME" => Ok(format!("{}/cms", dir)),
-    _ => panic!("nya"),
-  }
 }
 
 impl Config {
@@ -99,14 +96,13 @@ impl Config {
       Err(err) => return Err((format!("{:?}", err), 1)),
     };
 
-    match config_file.read_to_end(&mut buf) {
+    if let Some(err) = config_file.read_to_end(&mut buf).err() {
-      Ok(_) => {},
+      return Err((format!("{:?}", err), EX_DATAERR));
-      Err(err) => return Err((format!("{:?}", err), 1)),
+    }
-    };
 
     let toml = String::from_utf8(buf).unwrap();
 
-    match Config::deserialize(ValueDeserializer::new(&toml)) {
+    match toml::from_str(&toml) {
       Ok(val) => Ok(val),
       Err(err) => Err((format!("{:?}", err), 1)),
     }
@@ -125,7 +121,7 @@ impl PageMeta {
     match Self::deserialize(ValueDeserializer::new(&input)) {
       Ok(val) => Ok(val),
       Err(_) => {
-        Err(("Could not deserialized TOML.".to_owned(), EX_DATAERR))
+        Err(("Invalid configuration file.".to_owned(), EX_DATAERR))
       },
     }
   }

src/main.rs

@@ -39,102 +39,82 @@ fn main() {
   let mut options = Options::empty();
   options.insert(Options::all());
   
-  let config_path = match get_path("XDG_CONFIG_DIR") {
+  let config = Config::read_config(
-    Ok(path) => path,
+    get_path("XDG_CONFIG_DIR").unwrap_or_else(|(err, code)| {
-    Err((err, code)) => {
       eprintln!("{}: {}", argv[0], err);
       exit(code);
-    },
+    })
-  };
+  ).unwrap_or_else(|(err, code)| {
-  
+    eprintln!("{}: {}", argv[0], err);
-  let config = match Config::read_config(config_path) {
+    exit(code);
-    Ok(val) => val,
+  });
-    Err((err, code)) => {
-      eprintln!("{}: {}", argv[0], err);
-      exit(code);
-    }
-  };
 
-  let template_files = match read_dir(&config.template_dir) {
+  let mut files = get_contents(
-    Ok(files) => files,
+    read_dir(&config.content_dir).unwrap_or_else(|_| {
-    Err(_) => {
+        eprintln!(
-      eprintln!("{}: {}: Directory not found.", argv[0], &config.template_dir);
+          "{}: {}: No such file or directory.",
+          argv[0],
+          &config.content_dir
+        );
+        exit(EX_UNAVAILABLE);
+    })
+  ).unwrap_or_else(|(err, code)| {
+    eprintln!("{}: {}", argv[0], err);
+    exit(code);
+  });
+
+  let mut templates = get_templates(
+    read_dir(&config.template_dir).unwrap_or_else(|_| {
+      eprintln!(
+        "{}: {}: No such file or directory.",
+        argv[0],
+        &config.template_dir
+      );
       exit(EX_UNAVAILABLE);
-    },
+    })
-  };
+  ).unwrap_or_else(|(err, code)| {
-
+    eprintln!("{}: {}", argv[0], err);
-  let content_files = match read_dir(&config.content_dir) {
+    exit(code);
-    Ok(files) => files,
+  });
-    Err(_) => {
-      eprintln!("{}: {}: Directory not found.", argv[0], &config.content_dir);
-      exit(EX_UNAVAILABLE);
-    },
-  };
-  
-  let mut files = match get_contents(content_files) {
-    Ok(files) => files,
-    Err((err, code)) => {
-      eprintln!("{}: {}", argv[0], err);
-      exit(code);
-    },
-  };
-
-  let mut templates = match get_templates(template_files) {
-    Ok(templates) => templates,
-    Err((err, code)) => {
-      eprintln!("{}: {}", argv[0], err);
-      exit(code);
-    },
-  };
 
   for content_file in files.drain() {
     let (content_name, (md, toml)) = content_file;
     let mut output = String::new();
     html::push_html(&mut output, Parser::new_ext(&md, options));
 
-    let meta_info = match PageMeta::read_meta(toml.to_owned()) {
+    let meta_info = PageMeta::read_meta(
-      Ok(info) => info,
+      toml.to_owned()
-      Err((err, code)) => {
+    ).unwrap_or_else(|(err, code)| {
-        eprintln!("{}: {}", argv[0], err);
+      eprintln!("{}: {}", argv[0], err);
-        exit(code);
+      exit(code);
-      },
+    });
-    };
 
-    let template = match templates.get_mut(&meta_info.template) {
+    let dom = templates.get_mut(&meta_info.template).unwrap_or_else(|| {
-      Some(template) => template,
+      eprintln!(
-      None => {
+        "{}: {}: No such template “{}”.",
-        eprintln!(
+        argv[0],
-          "{}: {}: No such template “{}”.",
+        content_name,
-          argv[0],
+        meta_info.template,
-          content_name,
+      );
-          meta_info.template,
+      exit(EX_UNAVAILABLE);
-        );
+    }).get_mut_ref();
-        exit(EX_UNAVAILABLE);
-      },
-    };
 
-    let mut html_file = match File::create(format!(
+    let mut html_file = File::create(format!(
       "{}/{}.html",
       config.output_dir,
       meta_info.template,
-    )) {
+    )).unwrap_or_else(|_| {
-      Ok(file) => file,
+      eprintln!(
-      Err(_) => {
+        "{}: {}: Unable to create output file.",
-        eprintln!(
+        argv[0],
-          "{}: {}: Unable to create output file.",
+        config.output_dir,
-          argv[0],
+      );
-          config.output_dir,
+      exit(EX_OSERR);
-        );
+    });
-        exit(EX_OSERR);
-      },
-    };
 
-    match html_file.write(output.as_bytes()) {
+    html_file.write(output.as_bytes()).unwrap_or_else(|err| {
-      Ok(_) => {},
+      eprintln!("{}: {}", argv[0], err);
-      Err(err) => {
+      exit(EX_SOFTWARE);
-        eprintln!("{}: {}", argv[0], err);
+    });
-        exit(EX_SOFTWARE);
-      },
-    };
   }
 }

src/parse.rs

@@ -86,8 +86,8 @@ pub fn get_templates(
     let (file_name, contents) = entry;
 
     let dom = match unsafe {
-      tl::parse_owned(contents, ParserOptions::default()) }
+      tl::parse_owned(contents, ParserOptions::default())
-    {
+    } {
       Ok(dom) => dom,
       Err(err) => return Err((format!("{:?}", err), EX_DATAERR)),
     };
@@ -115,7 +115,6 @@ pub fn read_files(
         return Err((format!("Invalid file name."), EX_DATAERR));
       },
     };
-
     let contents = match File::open(&file_name) {
       Ok(mut md_file) => {
         md_file.read_to_end(&mut buf).unwrap();
@@ -123,7 +122,7 @@ pub fn read_files(
       },
       Err(_) => {
         return Err((
-          format!("{}: No such file or directory.", file_name),
+          format!("No such file or directory."),
           EX_UNAVAILABLE
         ));
       },