chore: Make clippy happy

Fix all clippy lints, except one, I kept it for @ngp because I'm not
100% sure what the correct behavior is

```rust
// src/util.rs:11
pub fn flopen(path: PathBuf, mode: FlockArg) -> Result<Flock<File>> {
let file = OpenOptions::new()
.read(true)
.write(true)
.create(true) // clippy: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_open_options
.open(path)?;
Flock::lock(file, mode).map_err(|(_, errno)| Error::Lock(errno))
}
```

Fixes: #4
Signed-off-by: Awiteb <[e-mail]>

src/attrs.rs

···
+use std::collections::btree_map::Entry;
 use std::collections::btree_map::{IntoIter as BTreeIntoIter, Iter as BTreeMapIter};
 use std::collections::BTreeMap;
 use std::iter::Chain;
···
     type IntoIter = Chain<BTreeIntoIter<String, String>, BTreeIntoIter<String, String>>;
 
     fn into_iter(self) -> Self::IntoIter {
-        self.written.into_iter().chain(self.updated.into_iter())
+        self.written.into_iter().chain(self.updated)
     }
 }
 
···
     }
 
     pub(crate) fn insert(&mut self, key: String, value: String) -> Option<String> {
-        if self.updated.contains_key(&key) {
-            self.updated.insert(key, value)
-        } else {
-            let maybe_old_value = self.written.get(&key);
-            self.updated.insert(key, value);
-            maybe_old_value.cloned()
+        match self.updated.entry(key.clone()) {
+            Entry::Occupied(mut e) => Some(e.insert(value)),
+            Entry::Vacant(e) => {
+                e.insert(value);
+                let maybe_old_value = self.written.get(&key);
+                maybe_old_value.cloned()
+            }
         }
     }
 

src/fzf.rs

···
     // unwrap: this can never fail
     let child_in = child.stdin.as_mut().unwrap();
     for item in input.into_iter() {
-        write!(child_in, "{item}\n")?;
+        writeln!(child_in, "{item}")?;
     }
     let output = child.wait_with_output()?;
     if output.stdout.is_empty() {

src/main.rs

···
 }
 
 fn parse_id(s: &str) -> std::result::Result<Id, &'static str> {
-    Ok(Id::from_str(s).map_err(|_| "Unable to parse tsk- ID")?)
+    Id::from_str(s).map_err(|_| "Unable to parse tsk- ID")
 }
 
 #[derive(Parser)]
···
     fn from(value: TaskId) -> Self {
         if let Some(id) = value.id.map(Id::from).or(value.tsk_id) {
             TaskIdentifier::Id(id)
-        } else {
-            if value.find.find {
-                TaskIdentifier::Find {
-                    search_body: value.find.args.search_body,
-                    archived: false,
-                }
-            } else {
-                TaskIdentifier::Relative(value.relative_id)
+        } else if value.find.find {
+            TaskIdentifier::Find {
+                search_body: value.find.args.search_body,
+                archived: false,
             }
+        } else {
+            TaskIdentifier::Relative(value.relative_id)
         }
     }
 }
···
     let mut title = if let Some(title) = title.title {
         title
     } else if let Some(title) = title.title_simple {
-        let joined = title.join(" ");
-        joined
+        title.join(" ")
     } else {
         "".to_string()
     };
···
 
 fn command_list(dir: PathBuf, all: bool, count: usize) -> Result<()> {
     let workspace = Workspace::from_path(dir)?;
-    let stack = if all {
-        workspace.read_stack()?
-    } else {
-        workspace.read_stack()?
-    };
+    let stack = workspace.read_stack()?;
+
     if stack.empty() {
         println!("*No tasks*");
         exit(0);
-    } else {
-        if !all {
-            for stack_item in stack.into_iter().take(count) {
-                if let Some(parsed) = task::parse(&stack_item.title) {
-                    println!("{}\t{}", stack_item.id, parsed.content.trim());
-                } else {
-                    println!("{stack_item}");
-                }
-            }
+    }
+
+    for (_, stack_item) in stack
+        .into_iter()
+        .enumerate()
+        .take_while(|(idx, _)| all || idx < &count)
+    {
+        if let Some(parsed) = task::parse(&stack_item.title) {
+            println!("{}\t{}", stack_item.id, parsed.content.trim());
         } else {
-            for stack_item in stack.into_iter() {
-                if let Some(parsed) = task::parse(&stack_item.title) {
-                    println!("{}\t{}", stack_item.id, parsed.content.trim());
-                } else {
-                    println!("{stack_item}");
-                }
-            }
+            println!("{stack_item}");
         }
     }
     Ok(())

src/stack.rs

···
 use std::collections::vec_deque::Iter;
 use std::collections::VecDeque;
 use std::fmt::Display;
+use std::fs::File;
 use std::io::{self, BufRead, BufReader, Seek, Write};
+use std::path::Path;
 use std::str::FromStr;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
-use std::{fs::File, path::PathBuf};
 
 use nix::fcntl::{Flock, FlockArg};
 
···
         let mut parts = s.trim().split("\t");
         let id: Id = parts
             .next()
-            .ok_or(Error::Parse(format!(
-                "Incomplete index line. Missing tsk ID"
-            )))?
+            .ok_or(Error::Parse(
+                "Incomplete index line. Missing tsk ID".to_owned(),
+            ))?
             .parse()?;
         let title: String = parts
             .next()
-            .ok_or(Error::Parse(format!(
-                "Incomplete index line. Missing title."
-            )))?
+            .ok_or(Error::Parse(
+                "Incomplete index line. Missing title.".to_owned(),
+            ))?
             .trim()
             .to_string();
         // parse the timestamp as an integer
···
 
 impl StackItem {
     /// Parses a [`StackItem`] from a string. The expected format is a tab-delimited line with the
-    /// files: task id	title
-    fn from_line(workspace_path: &PathBuf, line: String) -> Result<Self> {
+    /// files: task id title
+    fn from_line(workspace_path: &Path, line: String) -> Result<Self> {
         let mut stack_item: StackItem = line.parse()?;
 
         let task = util::flopen(
             workspace_path
                 .join(TASKSFOLDER)
-                .join(stack_item.id.to_filename()),
+                .join(stack_item.id.filename()),
             FlockArg::LockExclusive,
         )?;
         let task_modify_time = task.metadata()?.modified()?;
···
 }
 
 impl TaskStack {
-    pub fn from_tskdir(workspace_path: &PathBuf) -> Result<Self> {
+    pub fn from_tskdir(workspace_path: &Path) -> Result<Self> {
         let file = util::flopen(workspace_path.join(INDEXFILE), FlockArg::LockExclusive)?;
         let index = BufReader::new(&*file).lines();
         let mut all = VecDeque::new();
···
     pub fn swap(&mut self) {
         let tip = self.all.pop_front();
         let second = self.all.pop_front();
-        if tip.is_some() && second.is_some() {
-            self.all.push_front(tip.unwrap());
-            self.all.push_front(second.unwrap());
+        if let Some((tip, second)) = tip.zip(second) {
+            self.all.push_front(tip);
+            self.all.push_front(second);
         }
     }
 

src/task.rs

···
                     (']', ']', Some(InternalLink(il, s_pos))) => {
                         state.pop();
                         let contents = s.get(s_pos + 1..char_pos - 1)?;
-                        if let Ok(id) = Id::from_str(&contents) {
+                        if let Ok(id) = Id::from_str(contents) {
                             let linktext = format!(
                                 "{}{}",
                                 contents.purple(),
···
     fn test_link_no_terminal_link() {
         let input = "hello [world](https://ngp.computer\n";
         let output = parse(input).expect("parse to work");
-        assert!(output.links.len() == 0);
+        assert!(output.links.is_empty());
         assert_eq!(input, output.content);
     }
     #[test]
     fn test_link_bad_no_start_link() {
         let input = "hello [world]https://ngp.computer)\n";
         let output = parse(input).expect("parse to work");
-        assert!(output.links.len() == 0);
+        assert!(output.links.is_empty());
         assert_eq!(input, output.content);
     }
     #[test]
     fn test_link_bad_no_link() {
         let input = "hello [world]\n";
         let output = parse(input).expect("parse to work");
-        assert!(output.links.len() == 0);
+        assert!(output.links.is_empty());
         assert_eq!(input, output.content);
     }
 
···
     fn test_internal_link_bad() {
         let input = "hello [[tsk-123";
         let output = parse(input).expect("parse to work");
-        assert!(output.links.len() == 0);
+        assert!(output.links.is_empty());
         assert_eq!(input, output.content);
     }
 

src/util.rs

···
         .write(true)
         .create(true)
         .open(path)?;
-    Ok(Flock::lock(file, mode).map_err(|(_, errno)| Error::Lock(errno))?)
+    Flock::lock(file, mode).map_err(|(_, errno)| Error::Lock(errno))
 }
 
 /// Recursively searches upwards for a directory

src/workspace.rs

···
 }
 
 impl Id {
-    pub fn to_filename(&self) -> String {
+    /// Returns the filename for a task with this id.
+    pub fn filename(&self) -> String {
         format!("tsk-{}.tsk", self.0)
     }
 }
···
         }
         std::fs::create_dir(&tsk_dir)?;
         // Create the tasks directory
-        std::fs::create_dir(&tsk_dir.join("tasks"))?;
+        std::fs::create_dir(tsk_dir.join("tasks"))?;
         // Create the archive directory
-        std::fs::create_dir(&tsk_dir.join("archive"))?;
+        std::fs::create_dir(tsk_dir.join("archive"))?;
         let mut next = OpenOptions::new()
             .read(true)
             .write(true)
             .create(true)
+            .truncate(true)
             .open(tsk_dir.join("next"))?;
         next.write_all(b"1\n")?;
         Ok(())
···
         backlinks.insert(from);
         Self::set_xattr(
             &to_task.file,
-            BACKREFXATTR.into(),
+            BACKREFXATTR,
             &itertools::join(backlinks, ","),
         )
     }
···
         backlinks.remove(&from);
         Self::set_xattr(
             &to_task.file,
-            BACKREFXATTR.into(),
+            BACKREFXATTR,
             &itertools::join(backlinks, ","),
         )
     }
···
     type Err = Error;
 
     fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        let (tsk_id, task_content) = s.split_once('\t').ok_or(Error::Parse(format!(
-            "Missing TSK-ID or content or task parse."
-        )))?;
+        let (tsk_id, task_content) = s.split_once('\t').ok_or(Error::Parse(
+            "Missing TSK-ID or content or task parse.".to_owned(),
+        ))?;
         let (title, body) = task_content
             .split_once('\t')
-            .ok_or(Error::Parse(format!("Missing body for task parse.")))?;
+            .ok_or(Error::Parse("Missing body for task parse.".to_owned()))?;
         Ok(Self {
             id: tsk_id.parse()?,
             title: title.to_string(),