postit 0.2.3

Task manager on your CLI.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

//! Utilities to handle CSV files.
//!
//! The `Csv` struct implements the [`FilePersister`] trait.

use std::fs;
use std::path::{Path, PathBuf};

use crate::models::{Task, Todo};
use crate::traits::FilePersister;

/// Representation of a CSV file.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Csv {
    /// Location of the CSV file.
    path: PathBuf,
}

impl Csv {
    /// Constructor of the `Csv` struct.
    #[inline]
    pub fn new<T: AsRef<Path>>(path: T) -> Self {
        Self { path: path.as_ref().to_path_buf() }
    }

    /// Returns the header of a the csv file.
    #[inline]
    pub fn header() -> String {
        String::from("id,content,priority,checked\n")
    }
}

impl FilePersister for Csv {
    #[inline]
    fn boxed(self) -> Box<dyn FilePersister> {
        Box::new(self)
    }

    #[inline]
    fn path(&self) -> &PathBuf {
        &self.path
    }

    #[inline]
    fn default(&self) -> String {
        Self::header()
    }

    #[inline]
    fn tasks(&self) -> super::Result<Vec<Task>> {
        let lines: Vec<String> = fs::read_to_string(&self.path)?
            .lines()
            .map(|line| line.trim().to_owned())
            .filter(|line| !line.is_empty())
            .collect();

        let tasks = lines.iter().skip(1).map(Task::from).collect();

        Ok(tasks)
    }

    #[inline]
    fn open(&self) -> super::Result<fs::File> {
        Ok(fs::File::open(&self.path)?)
    }

    #[inline]
    fn write(&self, todo: &Todo) -> super::Result<()> {
        let sep = if cfg!(windows) { "\r\n" } else { "\n" };

        let mut bytes = Self::header().into_bytes();
        let mut tasks = todo
            .tasks
            .iter()
            .map(Task::as_line)
            .collect::<Vec<String>>()
            .join(sep)
            .into_bytes();

        bytes.append(&mut tasks);

        fs::write(&self.path, bytes)?;

        Ok(())
    }

    #[inline]
    fn clean(&self) -> super::Result<()> {
        fs::write(&self.path, self.default())?;

        Ok(())
    }

    #[inline]
    fn remove(&self) -> super::Result<()> {
        fs::remove_file(&self.path)?;

        Ok(())
    }
}