Implement message types and lobby join

secert-hitler/src/controller/gamemaster/gamemaster.rs

@@ -1,3 +1,4 @@
+/*
 use super::super::super::model::state::room::Room;
 
 pub struct GameMaster {
@@ -10,6 +11,24 @@ impl GameMaster {
          room: room,
       }
    }
+
+   fn run(&self) -> Result<String, String> {
+      self.run_lobby()?;
+      self.run_game_setup()?;
+      self.run_game()
+   }
+
+   fn run_lobby(&self) -> Result<String, String> {
+      Err("not impl".to_string())
+   }
+
+   fn run_game_setup(&self) -> Result<String, String> {
+      Err("not impl".to_string())
+   }
+
+   fn run_game(&self) -> Result<String, String> {
+      Err("not impl".to_string())
+   }
 }
 
 #[cfg(test)]
@@ -36,11 +55,29 @@ mod tests {
       let _ = GameMaster::new(r);
    }
 
-
    #[test]
    fn new_mockrooms() {
       let mut mrs = MockRooms::new();
       let r = mrs.create();
       let _ = GameMaster::new(r);
    }
+
+   #[test]
+   fn gm_run_lobby_fail() {
+      let gm = GameMaster::new(Box::new(MockRoom::create()));
+      panic!("not impl");
+   }
+
+   #[test]
+   fn gm_run_game_setup_fail() {
+      let gm = GameMaster::new(Box::new(MockRoom::create()));
+      panic!("not impl");
+   }
+
+   #[test]
+   fn gm_run_game_fail() {
+      let gm = GameMaster::new(Box::new(MockRoom::create()));
+      panic!("not impl");
+   }
 }
+*/

secert-hitler/src/controller/gamemaster/lobby.rs

@@ -0,0 +1,70 @@
+use super::player::Player;
+use super::super::super::model::state::event::Event;
+
+use std::collections::HashMap;
+
+pub struct Lobby {
+   players: HashMap<String, Player>,
+}
+
+impl Lobby {
+   fn new() -> Lobby {
+      Lobby{
+         players: HashMap::new(),
+      }
+   }
+
+   fn eat(&mut self, message: Event) {
+      let j = message.join();
+      if j.is_none() {
+         return;
+      }
+      let id = j.unwrap();
+      self.players.insert(id.clone(), Player::new(id));
+   }
+}
+
+#[cfg(test)]
+mod tests {
+   use super::*;
+
+   fn _dummy_event(m: &str) -> Event {
+      Event{
+         body: m.to_string(),
+         next: "a".to_string(),
+         sender: "b".to_string(),
+      }
+   }
+
+   #[test]
+   fn new_lobby() {
+      let _ = Lobby::new();
+   }
+
+   #[test]
+   fn eat_join() {
+      let mut l = Lobby::new();
+      let e = _dummy_event(r#"{"membership": "join", "displayname": "a"}"#);
+      let was = l.players.len();
+      l.eat(e);
+      assert!(was+1 == l.players.len(), "want {}, got {}: {:?}", was+1, l.players.len(), l.players);
+   }
+
+   #[test]
+   fn eat_join_malformatted() {
+      let mut l = Lobby::new();
+      let e = _dummy_event(r#"{"membership": "join"}"#);
+      let was = l.players.len();
+      l.eat(e);
+      assert!(was == l.players.len());
+   }
+
+   #[test]
+   fn eat_null() {
+      let mut l = Lobby::new();
+      let e = _dummy_event(r#"{"hello": "world"}"#);
+      let was = l.players.len();
+      l.eat(e);
+      assert!(was == l.players.len());
+   }
+}

secert-hitler/src/controller/gamemaster/mod.rs

@@ -1 +1,3 @@
 pub mod gamemaster;
+pub mod player;
+pub mod lobby;

secert-hitler/src/controller/gamemaster/player.rs

@@ -0,0 +1,22 @@
+#[derive(Clone, Debug)]
+pub struct Player {
+   id: String,
+}
+
+impl Player {
+   pub fn new(id: String) -> Player {
+      Player {
+         id: id,
+      }
+   }
+}
+
+#[cfg(test)]
+mod tests {
+   use super::*;
+
+   #[test]
+   fn new_player() {
+      let _ = Player::new("id".to_string());
+   }
+}

secert-hitler/src/model/state/event.rs

@@ -1,3 +1,5 @@
+use json;
+
 #[derive(Clone, Debug)]
 pub struct Event {
    pub sender: String,
@@ -5,15 +7,134 @@ pub struct Event {
    pub next: String,
 }
 
+#[derive(PartialEq, Eq, Debug)]
+pub enum EventType {
+   Null,
+   Join,
+   Create,
+   Message,
+}
+
+impl Event {
+   pub fn mode(&self) -> EventType {
+      let d = json::parse(&self.body).unwrap();
+      if d["membership"].is_string() {
+         return match d["membership"].as_str().unwrap().to_string().as_ref() {
+            "join" => EventType::Join,
+            _ => EventType::Null,
+         };
+      }
+      if d["creator"].is_string() {
+         return EventType::Create;
+      }
+      if d["msgtype"].is_string() {
+         return match d["msgtype"].as_str().unwrap().to_string().as_ref() {
+            "m.text" => EventType::Message,
+            _ => EventType::Null,
+         };
+      }
+      EventType::Null
+   }
+
+   pub fn join(&self) -> Option<String> {
+      let d = json::parse(&self.body).unwrap();
+      match self.mode() {
+         EventType::Join => true,
+         _ => return None,
+      };
+      let o = d["displayname"].as_str();
+      if o.is_none() {
+         return None;
+      }
+      Some(o.unwrap().to_string())
+   }
+}
+
 #[cfg(test)]
 mod tests {
+   use super::*;
+
+   fn _dummy() -> Event {
+      Event{
+         sender: "sender".to_string(),
+         body: r#"{}"#.to_string(),
+         next: "next".to_string(),
+      }
+   }
+
    #[test]
    fn event() {
-      let e = super::Event{
+      let e = Event{
          sender: "sender".to_string(),
          body: "body".to_string(),
          next: "next".to_string(),
       };
       println!("{:?}", e);
    }
+
+   #[test]
+   fn mode_null() {
+      let mut e = _dummy();
+      e.body = r#"{
+      }"#.to_string();
+      assert!(e.mode() == EventType::Null);
+   }
+
+   #[test]
+   fn mode_create() {
+      let mut e = _dummy();
+      e.body = r#"{
+         "creator": "abc"
+      }"#.to_string();
+      assert!(e.mode() == EventType::Create);
+   }
+
+   #[test]
+   fn mode_msgtype() {
+      let mut e = _dummy();
+      e.body = r#"{
+         "msgtype": "m.text"
+      }"#.to_string();
+      assert!(e.mode() == EventType::Message);
+   }
+
+   #[test]
+   fn mode_join() {
+      let mut e = _dummy();
+      e.body = r#"{
+         "membership": "join"
+      }"#.to_string();
+      assert!(e.mode() == EventType::Join);
+   }
+
+   #[test]
+   fn join_some() {
+      let mut e = _dummy();
+      e.body = r#"{
+         "displayname": "hi",
+         "membership": "join"
+      }"#.to_string();
+      let j = e.join();
+      assert!(j.is_some());
+   }
+
+   #[test]
+   fn join_some_bad() {
+      let mut e = _dummy();
+      e.body = r#"{
+         "membership": "join"
+      }"#.to_string();
+      let j = e.join();
+      assert!(j.is_none());
+   }
+
+   #[test]
+   fn join_none() {
+      let mut e = _dummy();
+      e.body = r#"{
+         "a": "b"
+      }"#.to_string();
+      let j = e.join();
+      assert!(j.is_none());
+   }
 }