complish 0.0.1

Core library for project-aware task management with git integration
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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use std::{
  cmp::Ordering,
  fmt::{Display, Formatter, Result as FmtResult},
  str::FromStr,
};

use eyre::{Error, Result, eyre};
use serde::{Deserialize, Serialize};

#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
pub enum TaskPriority {
  #[serde(rename = "p0")]
  Highest = 0,
  #[serde(rename = "p1")]
  High = 1,
  #[serde(rename = "p2")]
  #[default]
  Medium = 2,
  #[serde(rename = "p3")]
  Low = 3,
  #[serde(rename = "p4")]
  Lowest = 4,
}

impl Display for TaskPriority {
  fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
    match self {
      Self::Highest => write!(f, "p0"),
      Self::High => write!(f, "p1"),
      Self::Medium => write!(f, "p2"),
      Self::Low => write!(f, "p3"),
      Self::Lowest => write!(f, "p4"),
    }
  }
}

impl FromStr for TaskPriority {
  type Err = Error;

  fn from_str(s: &str) -> Result<Self> {
    match s {
      "p0" => Ok(Self::Highest),
      "p1" => Ok(Self::High),
      "p2" => Ok(Self::Medium),
      "p3" => Ok(Self::Low),
      "p4" => Ok(Self::Lowest),
      _ => Err(eyre!("Invalid priority")),
    }
  }
}

impl Ord for TaskPriority {
  fn cmp(&self, other: &Self) -> Ordering {
    (other.clone() as u8).cmp(&(self.clone() as u8))
  }
}

impl PartialOrd for TaskPriority {
  fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
    Some(self.cmp(other))
  }
}

#[cfg(test)]
mod tests {
  use super::*;

  mod display {
    use pretty_assertions::assert_eq;

    use super::*;

    #[test]
    fn it_displays_correctly() {
      assert_eq!(TaskPriority::Highest.to_string(), "p0");
      assert_eq!(TaskPriority::High.to_string(), "p1");
      assert_eq!(TaskPriority::Medium.to_string(), "p2");
      assert_eq!(TaskPriority::Low.to_string(), "p3");
      assert_eq!(TaskPriority::Lowest.to_string(), "p4");
    }
  }

  mod from_str {
    use pretty_assertions::assert_eq;

    use super::*;

    #[test]
    fn it_parses_correctly() {
      assert_eq!(TaskPriority::from_str("p0").unwrap(), TaskPriority::Highest);
      assert_eq!(TaskPriority::from_str("p1").unwrap(), TaskPriority::High);
      assert_eq!(TaskPriority::from_str("p2").unwrap(), TaskPriority::Medium);
      assert_eq!(TaskPriority::from_str("p3").unwrap(), TaskPriority::Low);
      assert_eq!(TaskPriority::from_str("p4").unwrap(), TaskPriority::Lowest);
    }

    #[test]
    fn it_errors_on_invalid_input() {
      assert!(TaskPriority::from_str("p5").is_err());
    }
  }

  mod ordering {
    use super::*;

    #[test]
    fn it_orders_correctly() {
      assert!(TaskPriority::Highest > TaskPriority::High);
      assert!(TaskPriority::High > TaskPriority::Medium);
      assert!(TaskPriority::Medium > TaskPriority::Low);
      assert!(TaskPriority::Low > TaskPriority::Lowest);
    }
  }
}