#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum TaskObligationKind {
Applied,
Verified,
Rules,
Knowledge,
Acceptance,
}
impl TaskObligationKind {
pub const ALL: [Self; 5] = [
Self::Applied,
Self::Verified,
Self::Rules,
Self::Knowledge,
Self::Acceptance,
];
pub fn label(&self) -> &'static str {
match self {
Self::Applied => "applied",
Self::Verified => "verified",
Self::Rules => "rules",
Self::Knowledge => "knowledge",
Self::Acceptance => "acceptance",
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum TaskObligationState {
Satisfied,
Outstanding,
Unknown,
}
impl TaskObligationState {
pub fn label(&self) -> &'static str {
match self {
Self::Satisfied => "satisfied",
Self::Outstanding => "outstanding",
Self::Unknown => "unknown",
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct TaskObligation {
kind: TaskObligationKind,
state: TaskObligationState,
detail: String,
}
impl TaskObligation {
pub fn new(
kind: TaskObligationKind,
state: TaskObligationState,
detail: impl Into<String>,
) -> Self {
Self {
kind,
state,
detail: detail.into(),
}
}
pub fn satisfied(kind: TaskObligationKind, detail: impl Into<String>) -> Self {
Self::new(kind, TaskObligationState::Satisfied, detail)
}
pub fn outstanding(kind: TaskObligationKind, detail: impl Into<String>) -> Self {
Self::new(kind, TaskObligationState::Outstanding, detail)
}
pub fn unknown(kind: TaskObligationKind, detail: impl Into<String>) -> Self {
Self::new(kind, TaskObligationState::Unknown, detail)
}
pub fn kind(&self) -> TaskObligationKind {
self.kind
}
pub fn state(&self) -> TaskObligationState {
self.state
}
pub fn detail(&self) -> &str {
&self.detail
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum TaskVerdict {
Complete,
Incomplete,
Unknown,
}
impl TaskVerdict {
pub fn label(&self) -> &'static str {
match self {
Self::Complete => "complete",
Self::Incomplete => "incomplete",
Self::Unknown => "unknown",
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct TaskCompletion {
obligations: Vec<TaskObligation>,
}
impl TaskCompletion {
pub fn new(obligations: Vec<TaskObligation>) -> Result<Self, String> {
for kind in TaskObligationKind::ALL {
let count = obligations
.iter()
.filter(|obligation| obligation.kind == kind)
.count();
if count != 1 {
return Err(format!(
"a maintenance task carries exactly one `{}` obligation and this set has {count}; \
a missing obligation is not the same as a satisfied one",
kind.label()
));
}
}
Ok(Self { obligations })
}
pub fn obligations(&self) -> Vec<&TaskObligation> {
let mut ordered = TaskObligationKind::ALL
.iter()
.filter_map(|kind| {
self.obligations
.iter()
.find(|obligation| obligation.kind == *kind)
})
.collect::<Vec<_>>();
ordered.sort_by_key(|obligation| obligation.kind);
ordered
}
pub fn verdict(&self) -> TaskVerdict {
if self
.obligations
.iter()
.all(|obligation| obligation.state == TaskObligationState::Satisfied)
{
return TaskVerdict::Complete;
}
if self
.obligations
.iter()
.any(|obligation| obligation.state == TaskObligationState::Outstanding)
{
return TaskVerdict::Incomplete;
}
TaskVerdict::Unknown
}
pub fn is_complete(&self) -> bool {
self.verdict() == TaskVerdict::Complete
}
pub fn open_obligations(&self) -> Vec<&TaskObligation> {
self.obligations()
.into_iter()
.filter(|obligation| obligation.state != TaskObligationState::Satisfied)
.collect()
}
pub fn summary(&self) -> String {
let mut text = String::new();
for obligation in self.obligations() {
text.push_str(&format!(
" {:<12} {:<12} {}\n",
obligation.kind.label(),
obligation.state.label(),
obligation.detail
));
}
text
}
}
#[cfg(test)]
#[path = "task_tests.rs"]
mod task_tests;