Deal with all lints

diff --git a/src/archiver/gemini.rs b/src/archiver/gemini.rs
index b74d27b230c3a5885e1149f510aa99a0257949d4..298ace8e5352f39261aff0a51b41377f4bbf06f6 100644 (file)
--- a/src/archiver/gemini.rs
+++ b/src/archiver/gemini.rs
@@ -1,4 +1,4 @@
-use crate::template::{find, parse, TemplateContext};
+use crate::template::{find, parse, Context};
 use std::fs::write;
 use std::io::{Error, ErrorKind::Other, Result};
 use std::path::Path;
@@ -9,7 +9,7 @@ pub fn archive(
     _: &Path,
     template_directory: &Path,
     target: &Path,
-    context: &TemplateContext,
+    context: &Context,
 ) -> Result<()> {
     if let Some(template) = find(template_directory, FILENAME) {
         let parsed_template = parse(&template)

diff --git a/src/archiver/gopher.rs b/src/archiver/gopher.rs
index fc0c04f221a6516a58397ee652de76e5a252a368..454e8c4ba8b6feeda7ea9b831999a798400a7314 100644 (file)
--- a/src/archiver/gopher.rs
+++ b/src/archiver/gopher.rs
@@ -1,4 +1,4 @@
-use crate::template::{find, parse, TemplateContext};
+use crate::template::{find, parse, Context};
 use std::fs::write;
 use std::io::{Error, ErrorKind::Other, Result};
 use std::path::Path;
@@ -9,7 +9,7 @@ pub fn archive(
     _: &Path,
     template_directory: &Path,
     target: &Path,
-    context: &TemplateContext,
+    context: &Context,
 ) -> Result<()> {
     if let Some(template) = find(template_directory, FILENAME) {
         let parsed_template = parse(&template)

diff --git a/src/archiver/mod.rs b/src/archiver/mod.rs
index 4631bcbfc040f0a9badb453ceedec1574cfa19da..ba8dd691ba422ba110ff0a5792919f0a5a4cb7a1 100644 (file)
--- a/src/archiver/mod.rs
+++ b/src/archiver/mod.rs
@@ -2,7 +2,7 @@ mod gemini;
 mod gopher;
 mod raw;
 
-use crate::template::{TemplateContext, TemplateValue};
+use crate::template::{Context, Value};
 use std::collections::HashMap;
 use std::fs::read_dir;
 use std::io::Result;
@@ -16,10 +16,10 @@ struct ArchiveEntry {
     slug: String,
 }
 
-type Archiver = fn(&Path, &Path, &Path, &TemplateContext) -> Result<()>;
+type Archiver = fn(&Path, &Path, &Path, &Context) -> Result<()>;
 
 impl ArchiveEntry {
-    pub fn to_template_context(archive_entries: &[ArchiveEntry]) -> TemplateContext {
+    pub fn to_template_context(archive_entries: &[ArchiveEntry]) -> Context {
         let mut context = HashMap::new();
 
         let archive_entries_collection = archive_entries
@@ -29,25 +29,25 @@ impl ArchiveEntry {
 
         context.insert(
             "archive_length".to_string(),
-            TemplateValue::Unsigned(archive_entries.len().try_into().unwrap()),
+            Value::Unsigned(archive_entries.len().try_into().unwrap()),
         );
         context.insert(
             "posts".to_string(),
-            TemplateValue::Collection(archive_entries_collection),
+            Value::Collection(archive_entries_collection),
         );
 
         context
     }
 
-    pub fn to_template_value(&self) -> TemplateContext {
+    pub fn to_template_value(&self) -> Context {
         let mut context = HashMap::new();
 
-        context.insert("id".to_string(), TemplateValue::String(self.id.clone()));
+        context.insert("id".to_string(), Value::String(self.id.clone()));
 
-        context.insert("slug".to_string(), TemplateValue::String(self.slug.clone()));
+        context.insert("slug".to_string(), Value::String(self.slug.clone()));
 
         if let Some(title) = self.title() {
-            context.insert("title".to_string(), TemplateValue::String(title));
+            context.insert("title".to_string(), Value::String(title));
         }
 
         context

diff --git a/src/archiver/raw.rs b/src/archiver/raw.rs
index c3dc1cf098bd2de89619dc8111a1fa36aa437e5f..ce7ecb718e7c510928ef7ae14182d9a59319e2e7 100644 (file)
--- a/src/archiver/raw.rs
+++ b/src/archiver/raw.rs
@@ -1,14 +1,9 @@
-use crate::template::TemplateContext;
+use crate::template::Context;
 use crate::utils::recursively_copy;
 use std::io::Result;
 use std::path::Path;
 
-pub fn archive(
-    archive_directory: &Path,
-    _: &Path,
-    target: &Path,
-    _: &TemplateContext,
-) -> Result<()> {
+pub fn archive(archive_directory: &Path, _: &Path, target: &Path, _: &Context) -> Result<()> {
     if archive_directory.exists() {
         return recursively_copy(archive_directory, target);
     }

diff --git a/src/command/generate.rs b/src/command/generate.rs
index a79058de636fb4a78401534c9ca4b53034d3eb6b..b74b33b3dbb31abf80c7481e8fcf0443f7129819 100644 (file)
--- a/src/command/generate.rs
+++ b/src/command/generate.rs
@@ -16,12 +16,12 @@ impl Generate {
         Generate
     }
 
-    fn read_posts(&self, posts_directory: &Path, max_posts: u8) -> Vec<Post> {
+    fn read_posts(posts_directory: &Path, max_posts: u8) -> Vec<Post> {
         let mut posts = Vec::new();
 
         for i in 0..max_posts {
             let post_path = posts_directory.join(i.to_string());
-            match self.read_post(&post_path, i) {
+            match Generate::read_post(&post_path, i) {
                 Some(post) => posts.push(post),
                 None => continue,
             }
@@ -49,7 +49,7 @@ impl Generate {
         None
     }
 
-    fn read_post(&self, post_directory: &Path, index: u8) -> Option<Post> {
+    fn read_post(post_directory: &Path, index: u8) -> Option<Post> {
         let metadata_path = post_directory.join(METADATA_FILENAME);
         let metadata = Metadata::read_or_create(&metadata_path);
         let raw = Generate::find_blog_content(post_directory)?;
@@ -73,7 +73,7 @@ impl super::Command for Generate {
         let _ = remove_dir_all(&configuration.blog_output_directory);
         create_dir_all(&configuration.blog_output_directory)?;
 
-        let posts = self.read_posts(&configuration.posts_directory, configuration.max_posts);
+        let posts = Generate::read_posts(&configuration.posts_directory, configuration.max_posts);
         generate(
             &configuration.static_directory,
             &configuration.templates_directory,

diff --git a/src/configuration.rs b/src/configuration.rs
index 1c0e90512d819d331fc3667d0708bf8554c4302d..dd9a6a9b9f14889aa27aa4b9ce302cd778bc2497 100644 (file)
--- a/src/configuration.rs
+++ b/src/configuration.rs
@@ -81,13 +81,11 @@ impl Configuration {
             Ok(directory) => PathBuf::from(directory),
             Err(_) => match env::var(default_value) {
                 Ok(directory) => PathBuf::from(directory),
-                Err(_) => match env::var("HOME") {
-                    Ok(directory) => PathBuf::from(directory).join(home_fallback),
-                    Err(_) => panic!(
-                        "Could not find required directory, {} or {} should be set and readable.",
-                        user_override, default_value
-                    ),
-                },
+                Err(_) => env::var("HOME")
+                    .map_or_else(
+                        |_| panic!("Could not find required directory, {user_override} or {default_value} should be set and readable"),
+                        |directory| PathBuf::from(directory).join(home_fallback)
+                    )
             },
         }
         .join(path)

diff --git a/src/generator/html.rs b/src/generator/html.rs
index 7b369444478b442d3fdbe9c9f7610b5f87c38277..70cc3206c0fac5f3a4534ffe2f2023a2d2102a11 100644 (file)
--- a/src/generator/html.rs
+++ b/src/generator/html.rs
@@ -1,25 +1,22 @@
-use crate::template::{find, parse, TemplateContext};
+use crate::template::{find, parse, Context};
 use std::fs::write;
 use std::io::{Error, ErrorKind::Other, Result};
-use std::path::PathBuf;
+use std::path::Path;
 
 const FILENAME: &str = "index.html";
 
 pub fn generate(
-    _: &PathBuf,
-    template_directory: &PathBuf,
-    target: &PathBuf,
-    context: &TemplateContext,
+    _: &Path,
+    template_directory: &Path,
+    target: &Path,
+    context: &Context,
 ) -> Result<()> {
-    match find(template_directory, FILENAME) {
-        Some(template) => {
-            let parsed_template = parse(&template)
-                .ok_or_else(|| Error::new(Other, "Unable to parse HTML template"))?;
-            let rendered_template = parsed_template.render(context)?;
-            let location = target.join(FILENAME);
-            write(location, rendered_template)?;
-        }
-        None => {}
+    if let Some(template) = find(template_directory, FILENAME) {
+        let parsed_template =
+            parse(&template).ok_or_else(|| Error::new(Other, "Unable to parse HTML template"))?;
+        let rendered_template = parsed_template.render(context)?;
+        let location = target.join(FILENAME);
+        write(location, rendered_template)?;
     }
     Ok(())
 }

diff --git a/src/generator/mod.rs b/src/generator/mod.rs
index 293ad7df59d16af38a5d1c4dbe547471a86f3bf7..dbe1c2e3ef3162b871c63e72fa61fcb3ffaaeade 100644 (file)
--- a/src/generator/mod.rs
+++ b/src/generator/mod.rs
@@ -4,18 +4,20 @@ mod static_files;
 mod txt;
 
 use crate::post::Post;
-use crate::template::TemplateContext;
+use crate::template::Context;
 use std::io::Result;
-use std::path::PathBuf;
+use std::path::Path;
+
+type Generator = fn(&Path, &Path, &Path, &Context) -> Result<()>;
 
 pub fn generate(
-    static_directory: &PathBuf,
-    template_directory: &PathBuf,
-    output_directory: &PathBuf,
-    posts: &Vec<Post>,
+    static_directory: &Path,
+    template_directory: &Path,
+    output_directory: &Path,
+    posts: &[Post],
 ) -> Result<()> {
     let generators = available_generators();
-    let context = Post::to_template_context(&posts);
+    let context = Post::to_template_context(posts);
     for generator in generators {
         generator(
             static_directory,
@@ -27,7 +29,7 @@ pub fn generate(
     Ok(())
 }
 
-fn available_generators() -> Vec<fn(&PathBuf, &PathBuf, &PathBuf, &TemplateContext) -> Result<()>> {
+fn available_generators() -> Vec<Generator> {
     vec![
         static_files::generate,
         // These three are actually the same. Can generalize, don't know how in rust yet.

diff --git a/src/generator/rss.rs b/src/generator/rss.rs
index 9705f8e8dc7766440288e333e1beb1cb89d78e95..e79694e96c15de7cd48c95f84324c074e7e6f46b 100644 (file)
--- a/src/generator/rss.rs
+++ b/src/generator/rss.rs
@@ -1,25 +1,22 @@
-use crate::template::{find, parse, TemplateContext};
+use crate::template::{find, parse, Context};
 use std::fs::write;
 use std::io::{Error, ErrorKind::Other, Result};
-use std::path::PathBuf;
+use std::path::Path;
 
 const FILENAME: &str = "feed.xml";
 
 pub fn generate(
-    _: &PathBuf,
-    template_directory: &PathBuf,
-    target: &PathBuf,
-    context: &TemplateContext,
+    _: &Path,
+    template_directory: &Path,
+    target: &Path,
+    context: &Context,
 ) -> Result<()> {
-    match find(template_directory, FILENAME) {
-        Some(template) => {
-            let parsed_template = parse(&template)
-                .ok_or_else(|| Error::new(Other, "Unable to parse RSS template"))?;
-            let rendered_template = parsed_template.render(context)?;
-            let location = target.join(FILENAME);
-            write(location, rendered_template)?;
-        }
-        None => {}
+    if let Some(template) = find(template_directory, FILENAME) {
+        let parsed_template =
+            parse(&template).ok_or_else(|| Error::new(Other, "Unable to parse RSS template"))?;
+        let rendered_template = parsed_template.render(context)?;
+        let location = target.join(FILENAME);
+        write(location, rendered_template)?;
     }
     Ok(())
 }

diff --git a/src/generator/static_files.rs b/src/generator/static_files.rs
index 8c55de348b654cf9f53fc0b8c46934ec7893f687..b4ec9fdbae0dc2162d0267a509aa83a0cc514407 100644 (file)
--- a/src/generator/static_files.rs
+++ b/src/generator/static_files.rs
@@ -1,14 +1,9 @@
-use crate::template::TemplateContext;
+use crate::template::Context;
 use crate::utils::recursively_copy;
 use std::io::Result;
-use std::path::PathBuf;
+use std::path::Path;
 
-pub fn generate(
-    source: &PathBuf,
-    _: &PathBuf,
-    target: &PathBuf,
-    _: &TemplateContext,
-) -> Result<()> {
+pub fn generate(source: &Path, _: &Path, target: &Path, _: &Context) -> Result<()> {
     if source.exists() {
         return recursively_copy(source, target);
     }

diff --git a/src/generator/txt.rs b/src/generator/txt.rs
index e146c151aab6ad2eeb0be29c26c92b6e94d7ae96..0a53655c185913808684b01139676a3240016708 100644 (file)
--- a/src/generator/txt.rs
+++ b/src/generator/txt.rs
@@ -1,25 +1,22 @@
-use crate::template::{find, parse, TemplateContext};
+use crate::template::{find, parse, Context};
 use std::fs::write;
 use std::io::{Error, ErrorKind::Other, Result};
-use std::path::PathBuf;
+use std::path::Path;
 
 const FILENAME: &str = "index.txt";
 
 pub fn generate(
-    _: &PathBuf,
-    template_directory: &PathBuf,
-    target: &PathBuf,
-    context: &TemplateContext,
+    _: &Path,
+    template_directory: &Path,
+    target: &Path,
+    context: &Context,
 ) -> Result<()> {
-    match find(template_directory, FILENAME) {
-        Some(template) => {
-            let parsed_template = parse(&template)
-                .ok_or_else(|| Error::new(Other, "Unable to parse TXT template"))?;
-            let rendered_template = parsed_template.render(context)?;
-            let location = target.join(FILENAME);
-            write(location, rendered_template)?;
-        }
-        None => {}
+    if let Some(template) = find(template_directory, FILENAME) {
+        let parsed_template =
+            parse(&template).ok_or_else(|| Error::new(Other, "Unable to parse TXT template"))?;
+        let rendered_template = parsed_template.render(context)?;
+        let location = target.join(FILENAME);
+        write(location, rendered_template)?;
     }
     Ok(())
 }

diff --git a/src/main.rs b/src/main.rs
index 6c529ed216ac3f7c91cb353c10e63eeb7db376fc..ae3628972afba8792136050553bdddd010cd169f 100644 (file)
--- a/src/main.rs
+++ b/src/main.rs
@@ -22,9 +22,9 @@ fn main() -> Result<()> {
         result
     } else {
         match result {
-            Ok(_) => Ok(()),
+            Ok(()) => Ok(()),
             Err(e) => {
-                eprintln!("{}", e);
+                eprintln!("{e}");
                 std::process::exit(1);
             }
         }
@@ -44,19 +44,16 @@ fn run() -> Result<()> {
             let command_chain: Vec<Box<dyn Command>> = before_commands
                 .into_iter()
                 .chain(once(main_command))
-                .chain(after_commands.into_iter())
+                .chain(after_commands)
                 .collect();
 
             for command in command_chain {
-                let result = command.execute(arguments.get(2), &configuration, command_name);
-                if let Err(_) = result {
-                    return result;
-                }
+                command.execute(arguments.get(2), &configuration, command_name)?;
             }
 
             return Ok(());
         }
     }
 
-    Help::new().execute(None, &configuration, &"help".to_string())
+    Help::new().execute(None, &configuration, "help")
 }

diff --git a/src/metadata.rs b/src/metadata.rs
index e016db6d32d3fc0434ef1896e7359a9501289af2..fe657e4e90bceaf45374bd3c215b08c79dcfc7ab 100644 (file)
--- a/src/metadata.rs
+++ b/src/metadata.rs
@@ -14,17 +14,16 @@ pub struct Metadata {
 
 impl Metadata {
     pub fn read_or_create(file_path: &PathBuf) -> Metadata {
-        match Metadata::read_metadata_file(file_path) {
-            Some(metadata) => metadata,
-            None => {
-                let timestamp = SystemTime::now()
-                    .duration_since(UNIX_EPOCH)
-                    .map(|duration| duration.as_millis() as u64)
-                    .unwrap_or_else(|_| 0);
-                return Metadata {
-                    id: timestamp.to_string(),
-                    created_on: timestamp,
-                };
+        if let Some(metadata) = Metadata::read_metadata_file(file_path) {
+            metadata
+        } else {
+            let timestamp = SystemTime::now().duration_since(UNIX_EPOCH).map_or_else(
+                |_| 0,
+                |duration| u64::try_from(duration.as_millis()).expect("Timestamp is too big!"),
+            );
+            Metadata {
+                id: timestamp.to_string(),
+                created_on: timestamp,
             }
         }
     }
@@ -32,7 +31,7 @@ impl Metadata {
     pub fn created_on_utc(&self) -> Option<String> {
         let date =
             OffsetDateTime::from_unix_timestamp_nanos((self.created_on * 1_000_000).into()).ok()?;
-        return date.format(&Rfc2822).ok();
+        date.format(&Rfc2822).ok()
     }
 
     fn read_metadata_file(file_path: &PathBuf) -> Option<Metadata> {

diff --git a/src/post.rs b/src/post.rs
index afe6b7726fa36936432a7caa4ddc1f640e9d1311..6f2120e4825f31ee8a84ebbd87a6eb248ea22b7b 100644 (file)
--- a/src/post.rs
+++ b/src/post.rs
@@ -1,5 +1,5 @@
 use crate::metadata::Metadata;
-use crate::template::{TemplateContext, TemplateValue};
+use crate::template::{Context, Value};
 use std::collections::HashMap;
 
 pub struct Post {
@@ -10,82 +10,63 @@ pub struct Post {
 }
 
 impl Post {
-    pub fn to_template_context(posts: &Vec<Post>) -> TemplateContext {
+    pub fn to_template_context(posts: &[Post]) -> Context {
         let mut context = HashMap::new();
 
-        let posts_collection = posts.iter().map(|post| post.to_template_value()).collect();
-        context.insert(
-            "has_posts".to_string(),
-            TemplateValue::Bool(posts.len() > 0),
-        );
+        let posts_collection = posts.iter().map(Post::to_template_value).collect();
+        context.insert("has_posts".to_string(), Value::Bool(!posts.is_empty()));
         context.insert(
             "posts_length".to_string(),
-            TemplateValue::Unsigned(posts.len().try_into().unwrap()),
-        );
-        context.insert(
-            "posts".to_string(),
-            TemplateValue::Collection(posts_collection),
+            Value::Unsigned(posts.len().try_into().unwrap()),
         );
+        context.insert("posts".to_string(), Value::Collection(posts_collection));
 
         context
     }
-    pub fn to_template_value(&self) -> TemplateContext {
+    pub fn to_template_value(&self) -> Context {
         let mut context = HashMap::new();
 
         context.insert(
             "id".to_string(),
-            TemplateValue::String(format!("{}", self.metadata.id)),
+            Value::String(self.metadata.id.to_string()),
         );
         context.insert(
             "created_on".to_string(),
-            TemplateValue::Unsigned(self.metadata.created_on),
+            Value::Unsigned(self.metadata.created_on),
         );
 
         if let Some(created_on_utc) = self.metadata.created_on_utc() {
-            context.insert(
-                "created_on_utc".to_string(),
-                TemplateValue::String(created_on_utc),
-            );
+            context.insert("created_on_utc".to_string(), Value::String(created_on_utc));
         }
 
-        context.insert("title".to_string(), TemplateValue::String(self.title()));
-        context.insert(
-            "index".to_string(),
-            TemplateValue::Unsigned(self.index.into()),
-        );
-        context.insert(
-            "html".to_string(),
-            TemplateValue::String(format!("{}", self.html)),
-        );
+        context.insert("title".to_string(), Value::String(self.title()));
+        context.insert("index".to_string(), Value::Unsigned(self.index.into()));
+        context.insert("html".to_string(), Value::String(self.html.to_string()));
         context.insert(
             "escaped_html".to_string(),
-            TemplateValue::String(format!("{}", self.escaped_html())),
-        );
-        context.insert(
-            "raw".to_string(),
-            TemplateValue::String(format!("{}", self.raw)),
+            Value::String(self.escaped_html().to_string()),
         );
+        context.insert("raw".to_string(), Value::String(self.raw.to_string()));
         context
     }
 
     fn title(&self) -> String {
         self.raw
-            .trim()
-            .split('\n')
+            .lines()
             .next()
             .unwrap()
             .replace('#', "")
-            .replace("&", "&amp;")
+            .replace('&', "&amp;")
             .trim()
             .to_string()
     }
 
     fn escaped_html(&self) -> String {
         self.html
-            .replace("&", "&amp;")
-            .replace("<", "&lt;")
-            .replace(">", "&gt;")
-            .replace("\"", "&quot;")
-            .replace("'", "&apos;")
+            .replace('&', "&amp;")
+            .replace('<', "&lt;")
+            .replace('>', "&gt;")
+            .replace('"', "&quot;")
+            .replace('\'', "&apos;")
     }
 }

diff --git a/src/remote/git.rs b/src/remote/git.rs
index a8a901055c4cdbb13b951ac65720d75259cafd6e..5a791646479b3e297d71b78ba1d2105eabc9ac8c 100644 (file)
--- a/src/remote/git.rs
+++ b/src/remote/git.rs
@@ -1,5 +1,5 @@
 use std::io::{Error, ErrorKind::Other, Result};
-use std::path::PathBuf;
+use std::path::Path;
 use std::process::{Command, Stdio};
 use std::time::{SystemTime, UNIX_EPOCH};
 
@@ -17,7 +17,7 @@ impl super::Remote for Git {
         true
     }
 
-    fn sync_up(&self, remote: &str, directory: &PathBuf) -> Result<()> {
+    fn sync_up(&self, remote: &str, directory: &Path) -> Result<()> {
         let timestamp = SystemTime::now()
             .duration_since(UNIX_EPOCH)
             .map_err(|_| Error::new(Other, "Invalid time"))?
@@ -51,7 +51,7 @@ impl super::Remote for Git {
         Ok(())
     }
 
-    fn sync_down(&self, remote: &str, directory: &PathBuf) -> Result<()> {
+    fn sync_down(&self, remote: &str, directory: &Path) -> Result<()> {
         let commands = vec![
             format!("cd {} && git init -b main", directory.display()),
             format!("cd {} && git checkout .", directory.display()),

diff --git a/src/remote/mod.rs b/src/remote/mod.rs
index 49bfeb0adfa15dec9ea0de80bda1b58b55729bcb..656193675cbd0ee62a502ea3a5d8f05d20191e4c 100644 (file)
--- a/src/remote/mod.rs
+++ b/src/remote/mod.rs
@@ -2,30 +2,30 @@ mod git;
 
 use std::fs::{create_dir_all, remove_file, write, File};
 use std::io::{Error, ErrorKind::Other, Read, Result};
-use std::path::PathBuf;
+use std::path::Path;
 
 use git::Git;
 
 pub trait Remote {
     fn can_handle(&self, remote: &str) -> bool;
-    fn sync_up(&self, remote: &str, directory: &PathBuf) -> Result<()>;
-    fn sync_down(&self, remote: &str, directory: &PathBuf) -> Result<()>;
+    fn sync_up(&self, remote: &str, directory: &Path) -> Result<()>;
+    fn sync_down(&self, remote: &str, directory: &Path) -> Result<()>;
 }
 
-pub fn add(config_directory: &PathBuf, remote_config: &PathBuf, remote: &String) -> Result<()> {
+pub fn add(config_directory: &Path, remote_config: &Path, remote: &String) -> Result<()> {
     create_dir_all(config_directory)?;
     write(remote_config, remote)?;
     Ok(())
 }
 
-pub fn remove(remote_config: &PathBuf) -> Result<()> {
+pub fn remove(remote_config: &Path) -> Result<()> {
     if remote_config.exists() {
-        remove_file(remote_config)?
+        remove_file(remote_config)?;
     }
     Ok(())
 }
 
-pub fn sync_up(data_directory: &PathBuf, remote_config: &PathBuf) -> Result<()> {
+pub fn sync_up(data_directory: &Path, remote_config: &Path) -> Result<()> {
     let remote_address =
         read_remote(remote_config).ok_or_else(|| Error::new(Other, "No remote is configured"))?;
     create_dir_all(data_directory)?;
@@ -41,7 +41,7 @@ pub fn sync_up(data_directory: &PathBuf, remote_config: &PathBuf) -> Result<()>
     ))
 }
 
-pub fn sync_down(data_directory: &PathBuf, remote_config: &PathBuf) -> Result<()> {
+pub fn sync_down(data_directory: &Path, remote_config: &Path) -> Result<()> {
     let remote_address =
         read_remote(remote_config).ok_or_else(|| Error::new(Other, "No remote is configured"))?;
     create_dir_all(data_directory)?;
@@ -61,7 +61,7 @@ fn available_remotes() -> Vec<Box<dyn Remote>> {
     vec![Box::new(Git::new())]
 }
 
-fn read_remote(file_path: &PathBuf) -> Option<String> {
+fn read_remote(file_path: &Path) -> Option<String> {
     let mut file = File::open(file_path).ok()?;
     let mut contents = String::new();
     file.read_to_string(&mut contents).ok()?;

diff --git a/src/template.rs b/src/template.rs
index 9bd86448913b55109e2fd7d756dc2f7c15de51f1..57a2571d848da94977a722a4d52e8a804384d576 100644 (file)
--- a/src/template.rs
+++ b/src/template.rs
@@ -30,15 +30,15 @@ pub enum Token {
 impl std::fmt::Display for Token {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
-            Token::Text(label) => write!(f, "Text {}", label),
-            Token::DisplayDirective { content } => write!(f, "DisplayDirective {}", content),
+            Token::Text(label) => write!(f, "Text {label}"),
+            Token::DisplayDirective { content } => write!(f, "DisplayDirective {content}"),
             Token::ConditionalDirective {
                 condition,
                 children,
             } => {
-                write!(f, "ConditionalDirective {} [[[\n", condition)?;
+                writeln!(f, "ConditionalDirective {condition} [[[")?;
                 for child in children {
-                    write!(f, "\t{}\n", child)?;
+                    writeln!(f, "\t{child}")?;
                 }
                 write!(f, "\n]]]")
             }
@@ -47,9 +47,9 @@ impl std::fmt::Display for Token {
                 member_label,
                 children,
             } => {
-                write!(f, "{} in {}\n", collection, member_label)?;
+                writeln!(f, "{collection} in {member_label}")?;
                 for child in children {
-                    write!(f, "\t{}\n", child)?;
+                    writeln!(f, "\t{child}")?;
                 }
                 write!(f, "\n]]]")
             }
@@ -58,38 +58,38 @@ impl std::fmt::Display for Token {
 }
 
 #[derive(Clone)]
-pub enum TemplateValue {
+pub enum Value {
     String(String),
     Unsigned(u64),
     Bool(bool),
-    Collection(Vec<TemplateContext>),
-    Context(TemplateContext),
+    Collection(Vec<Context>),
+    Context(Context),
 }
 
-impl TemplateValue {
+impl Value {
     fn render(&self) -> String {
         match self {
-            TemplateValue::String(string) => string.to_string(),
-            TemplateValue::Unsigned(number) => format!("{}", number),
-            TemplateValue::Bool(bool) => format!("{}", bool),
-            _ => "".to_string(),
+            Value::String(string) => string.to_string(),
+            Value::Unsigned(number) => format!("{number}"),
+            Value::Bool(bool) => format!("{bool}"),
+            _ => String::new(),
         }
     }
 }
 
-pub type TemplateContext = HashMap<String, TemplateValue>;
+pub type Context = HashMap<String, Value>;
 
-struct TemplateContextGetter {}
-impl TemplateContextGetter {
-    fn get(context: &TemplateContext, path: &str) -> Option<TemplateValue> {
+struct ContextGetter {}
+impl ContextGetter {
+    fn get(context: &Context, path: &str) -> Option<Value> {
         let path_parts: Vec<&str> = path.split('.').collect();
-        TemplateContextGetter::recursively_get_value(context, &path_parts)
+        ContextGetter::recursively_get_value(context, &path_parts)
     }
 
-    fn recursively_get_value(context: &TemplateContext, path: &[&str]) -> Option<TemplateValue> {
+    fn recursively_get_value(context: &Context, path: &[&str]) -> Option<Value> {
         match context.get(path[0]) {
-            Some(TemplateValue::Context(next)) if path.len() > 1 => {
-                TemplateContextGetter::recursively_get_value(next, &path[1..])
+            Some(Value::Context(next)) if path.len() > 1 => {
+                ContextGetter::recursively_get_value(next, &path[1..])
             }
             Some(value) if path.len() == 1 => Some(value.clone()),
             _ => None,
@@ -97,23 +97,23 @@ impl TemplateContextGetter {
     }
 }
 
-pub struct ParsedTemplate {
+pub struct Parsed {
     pub tokens: Vec<Token>,
 }
 
-impl ParsedTemplate {
-    pub fn render(&self, context: &TemplateContext) -> Result<String> {
-        ParsedTemplate::render_tokens(&self.tokens, context)
+impl Parsed {
+    pub fn render(&self, context: &Context) -> Result<String> {
+        Parsed::render_tokens(&self.tokens, context)
     }
 
-    pub fn render_tokens(tokens: &Vec<Token>, context: &TemplateContext) -> Result<String> {
+    pub fn render_tokens(tokens: &Vec<Token>, context: &Context) -> Result<String> {
         let mut rendered_template: String = String::new();
         for token in tokens {
             match token {
-                Token::Text(contents) => rendered_template.push_str(&contents),
+                Token::Text(contents) => rendered_template.push_str(contents),
                 Token::DisplayDirective { content } => {
-                    let value = TemplateContextGetter::get(context, &content).ok_or_else(|| {
-                        Error::new(Other, format!("{} is not a valid key", content))
+                    let value = ContextGetter::get(context, content).ok_or_else(|| {
+                        Error::new(Other, format!("{content} is not a valid key"))
                     })?;
                     rendered_template.push_str(&value.render());
                 }
@@ -128,22 +128,21 @@ impl ParsedTemplate {
                         condition = condition[1..].to_string();
                     }
 
-                    let value =
-                        TemplateContextGetter::get(context, &condition).ok_or_else(|| {
-                            Error::new(Other, format!("{} is not a valid key", condition))
-                        })?;
+                    let value = ContextGetter::get(context, &condition).ok_or_else(|| {
+                        Error::new(Other, format!("{condition} is not a valid key"))
+                    })?;
 
                     match value {
-                        TemplateValue::Bool(value) => {
+                        Value::Bool(value) => {
                             if negator ^ value {
                                 rendered_template
-                                    .push_str(&ParsedTemplate::render_tokens(children, context)?)
+                                    .push_str(&Parsed::render_tokens(children, context)?);
                             }
                             Ok(())
                         }
                         _ => Err(Error::new(
                             Other,
-                            format!("{} is not a boolean value", condition),
+                            format!("{condition} is not a boolean value"),
                         )),
                     }?;
                 }
@@ -152,29 +151,24 @@ impl ParsedTemplate {
                     member_label,
                     children,
                 } => {
-                    let value =
-                        TemplateContextGetter::get(context, &collection).ok_or_else(|| {
-                            Error::new(Other, format!("{} is not a valid key", collection))
-                        })?;
+                    let value = ContextGetter::get(context, collection).ok_or_else(|| {
+                        Error::new(Other, format!("{collection} is not a valid key"))
+                    })?;
 
                     match value {
-                        TemplateValue::Collection(collection) => {
+                        Value::Collection(collection) => {
                             for member in collection {
                                 let mut child_context = context.clone();
-                                child_context.insert(
-                                    member_label.to_string(),
-                                    TemplateValue::Context(member),
-                                );
-                                rendered_template.push_str(&ParsedTemplate::render_tokens(
-                                    &children,
-                                    &child_context,
-                                )?)
+                                child_context
+                                    .insert(member_label.to_string(), Value::Context(member));
+                                rendered_template
+                                    .push_str(&Parsed::render_tokens(children, &child_context)?);
                             }
                             Ok(())
                         }
                         _ => Err(Error::new(
                             Other,
-                            format!("{} is not a collection", collection),
+                            format!("{collection} is not a collection"),
                         )),
                     }?;
                 }
@@ -184,10 +178,10 @@ impl ParsedTemplate {
     }
 }
 
-pub fn parse(template: &str) -> Option<ParsedTemplate> {
+pub fn parse(template: &str) -> Option<Parsed> {
     let mut tokens = Vec::new();
     tokenize(template, &mut tokens).ok()?;
-    Some(ParsedTemplate { tokens })
+    Some(Parsed { tokens })
 }
 
 fn tokenize(template: &str, tokens: &mut Vec<Token>) -> Result<()> {