done 0.0.0-reserve

use task::task::Task;

use std::fmt;

pub struct List {
    pub tasks: Vec<Task>,
}

impl List {
    pub fn to_plaintext(&mut self) -> String {
        self.tasks.sort();
        self.tasks.iter()
            .map(|task| task.to_plaintext())
            .collect::<Vec<_>>()
            .join("\n")
    } 
}

impl fmt::Display for List {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let mut list_string = String::new();
        list_string.push_str("List(\n");
        for task in self.tasks.iter() {
            list_string.push_str(format!("{}", task).as_str());
        }
        list_string.push_str("\n)");
        write!(f, "{}", list_string)
    }
}

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

    #[test]
    fn test_list_to_plaintext() {
        let mut list = List {
            tasks: vec![
                Task { name: "done".to_string(), state: TaskState::Done },
                Task { name: "blocked".to_string(), state: TaskState::Blocked },
                Task { name: "backlog".to_string(), state: TaskState::Backlog },
                Task { name: "current".to_string(), state: TaskState::Current },
            ],
        };

        // Should sort and return in correct order
        let expected_list_str =
            "~ current\n\
             - backlog\n\
             = blocked\n\
             + done";

        assert_eq!(list.to_plaintext(), expected_list_str);
    }
}