mob 0.4.3

A CLI for mobbing from the comfort of your console
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
115

use clap::ArgMatches;
use client::Client;
use member::{self, NewMember, Member};
use super::Result;

pub fn create<C: Client>(matches: &ArgMatches, client: &C) -> Result<Team> {
    let time_per_driver_in_minutes = matches.value_of("minutes")
        .map(|minutes| minutes.parse::<f64>())
        .unwrap_or(Ok(5.0))?;

    let new_members = member::build(matches);

    let new_team = NewTeam::new(new_members, time_per_driver_in_minutes);
    let team = client.create_team(&new_team)?;

    Ok(team)
}

#[derive(Debug, Serialize)]
pub struct NewTeam {
    time: f64,
    members: Vec<NewMember>,
}

impl NewTeam {
    fn new(new_members: Vec<NewMember>, time: f64) -> NewTeam {
        NewTeam {
            time: time,
            members: new_members,
        }
    }
}

#[derive(Debug, Deserialize)]
pub struct Team {
    pub id: i32,
    pub driver: Member,
    pub time: f64,
    pub members: Vec<Member>,
}

impl Team {
    pub fn next_driver(&self) -> Member {
        let next_driver_position = next_driver_position(
            self.driver.position + 1,
            &self.members);

        let mut next_driver = self.members
            .clone()
            .into_iter()
            .find(|member| member.position == next_driver_position)
            .expect("Member to exist at position");
        next_driver.driver = true;
        next_driver
    }
}

fn next_driver_position(next_position: i32, members: &Vec<Member>) -> i32 {
    match members.into_iter().find(|member| member.position == next_position) {
        Some(driver) => {
            if driver.is_active() {
                driver.position
            } else {
                next_driver_position(driver.position + 1, members)
            }
        }
        None => next_driver_position(1, members)

    }
}

#[cfg(test)]
mod test {
    use super::{Member, Team};

    #[test]
    fn test_next_driver() {
        let current_driver = Member::new(1, "Mike", 1, true, true);
        let next_driver = Member::new(2, "Brian", 2, true, true);
        let members: Vec<Member> = vec![
            current_driver.clone(),
            next_driver.clone(),
            Member::new(3, "Patrick", 3, true, false)];

        let team = Team {
            id: 1,
            driver: current_driver,
            time: 5.0,
            members: members,
        };

        assert_eq!(team.next_driver(), next_driver);
    }

    #[test]
    fn test_next_driver_ignores_inactive() {
        let current_driver  = Member::new(1, "Mike", 1, true, true);
        let inactive_driver  = Member::new(2, "Brian", 2, false, false);
        let next_driver  = Member::new(3, "Patrick", 3, true, true);

        let members: Vec<Member> = vec![
            current_driver.clone(),
            inactive_driver,
            next_driver.clone()];

        let team = Team {
            id: 1,
            driver: current_driver,
            time: 5.0,
            members: members,
        };

        assert_eq!(team.next_driver(), next_driver);
    }
}