maybe make imports better fuck idunno

secert-hitler/src/controller/mod.rs

@@ -1,2 +1 @@
 mod gamemaster;
-mod state;

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

@@ -1,19 +0,0 @@
-#[derive(Clone, Debug)]
-pub struct Event {
-   pub sender: String,
-   pub body: String,
-   pub next: String,
-}
-
-#[cfg(test)]
-mod tests {
-   #[test]
-   fn event() {
-      let e = super::Event{
-         sender: "sender".to_string(),
-         body: "body".to_string(),
-         next: "next".to_string(),
-      };
-      println!("{:?}", e);
-   }
-}

secert-hitler/src/controller/state/mockroom.rs

@@ -1,150 +0,0 @@
-use super::room::Room;
-use super::event::Event;
-
-use rand::{self, Rng};
-use rand::distributions::Alphanumeric;
-use crossbeam_channel::{unbounded, Sender, Receiver};
-
-#[derive(Clone, Debug)]
-pub struct MockRoom {
-   last: String,
-   room_id: String,
-   events_s: Sender<Vec<Event>>,
-   events_r: Receiver<Vec<Event>>,
-}
-
-impl MockRoom {
-   pub fn create() -> MockRoom {
-      MockRoom::join(rands()) 
-   }
-
-   pub fn join(room_id: String) -> MockRoom {
-      let (s, r) = unbounded();
-      s.send(vec![]).ok().unwrap();
-      MockRoom {
-         last: "".to_string(),
-         room_id: room_id,
-         events_s: s,
-         events_r: r,
-      }
-   }
-
-   pub fn room(&self) -> impl Room {
-      self.clone()
-   }
-}
-
-impl Room for MockRoom {
-   fn sync(&mut self) -> Vec<Event> {
-      let mut unseen: Vec<Event> = vec![];
-      let mut last = self.last.clone();
-      let events = self.events_r.recv().ok().unwrap();
-      for e in &events {
-         if e.next == self.last {
-            unseen.clear();
-         } else {
-            unseen.push(e.clone());
-            last = e.next.clone();
-         }
-      }
-      self.events_s.send(events).ok().unwrap();
-      self.last = last;
-      return unseen;
-   }
-
-   fn send(&mut self, message: String) -> Result<&str, &str> {
-      let e = Event{
-         sender: rands(),
-         next: rands(),
-         body: message,
-      };
-      let mut events = self.events_r.recv().ok().unwrap();
-      events.push(e);
-      self.events_s.send(events).ok().unwrap();
-      Ok("ok")
-   }
-
-   fn room_id(&self) -> String {
-      self.room_id.clone()
-   }
-}
-
-impl Drop for MockRoom {
-   fn drop(&mut self) {
-      println!("MockRoom::drop not impl");
-   }
-}
-
-pub fn rands() -> String {
-   rand::thread_rng()
-      .sample_iter(&Alphanumeric)
-      .take(10)
-      .collect::<String>()
-}
-
-#[cfg(test)]
-mod tests {
-   use super::Room;
-   use super::MockRoom;
-   use super::Event;
-   use super::rands;
-
-   fn _dummy() -> MockRoom {
-      let mut r = MockRoom::create();
-      r.last = "1".to_string();
-      let mut events = r.events_r.recv().ok().unwrap();
-      for i in 0..5 {
-         events.push(Event{
-            sender: i.to_string(), 
-            next: i.to_string(), 
-            body: i.to_string(),
-         });
-      }
-      r.events_s.send(events).ok().unwrap();
-      r
-   }
-
-   #[test]
-   fn randstest() {
-      let a = rands();
-      let b = rands();
-      assert!(a != b, "a == {} == b == {}", a, b);
-   }
-
-   #[test]
-   fn create() {
-      let mut r: MockRoom = MockRoom::create();
-      println!("{:?}", r.sync());
-   }
-
-   #[test]
-   fn join() {
-      let rid = "a".to_string();
-      let r: MockRoom = MockRoom::join(rid.to_string());
-      assert!(r.room_id == rid);
-   }
-
-   #[test]
-   fn sync() {
-      let mut r = _dummy();
-      let events = r.sync();
-      assert!(events.len() == 3, "want {}, got {}: {:?}", 3, events.len(), events);
-      assert!(events[0].sender == "2");
-      assert!(events[0].body == "2");
-      assert!(events[0].next == "2");
-      assert!(r.last == "4", "want last==4, got {}", r.last);
-   }
-
-   #[test]
-   fn send() {
-      let mut r = _dummy();
-      let message = "message".to_string();
-      r.sync();
-      assert!(r.send(message.clone()).ok().unwrap() == "ok");
-      assert!(r.last == "4");
-      let events = r.sync();
-      assert!(events.len() == 1);
-      assert!(events[0].body == message, "want {}, got {}: {:?}", message, events[0].body, events);
-      assert!(r.last != "4");
-   }
-}

secert-hitler/src/controller/state/mockrooms.rs

@@ -1,123 +0,0 @@
-use super::rooms::Rooms;
-use super::room::Room;
-use super::mockroom::MockRoom;
-
-// #[derive(Clone, Debug)]
-pub struct MockRooms {
-   rooms: Vec<MockRoom>,
-}
-
-impl MockRooms {
-   pub fn new() -> MockRooms {
-      MockRooms {
-         rooms: vec![],
-      }
-   }
-}
-
-impl Rooms for MockRooms {
-   fn create(&mut self) -> Box<dyn Room> {
-      let room = MockRoom::create();
-      let _room = room.room();
-      self.rooms.push(room);
-      Box::new(_room)
-   }
-
-   fn join(&self, room_id: String) -> Result<Box<dyn Room>, &str> {
-      for r in &self.rooms {
-         if r.room_id() == room_id {
-            return Ok(Box::new(r.room()));
-         }
-      }
-      Err("not found")
-   }
-}
-
-#[cfg(test)]
-mod tests {
-   use super::MockRooms;
-   use super::MockRoom;
-   use super::Rooms;
-
-   fn _dummy() -> MockRooms {
-      let mut mrs = MockRooms::new();
-      for i in 0..5 {
-         let random = MockRoom::create();
-         mrs.rooms.push(random);
-         let joined = MockRoom::join(i.to_string());
-         mrs.rooms.push(joined);
-      }
-      assert!(mrs.rooms.len() == 10);
-      mrs
-   }
-
-   #[test]
-   fn mockrooms() {
-      let mrs = MockRooms::new();
-      assert!(mrs.rooms.len() == 0);
-   }
-
-   #[test]
-   fn create() {
-      let mut mrs = _dummy();
-      let was = mrs.rooms.len();
-      let _ = mrs.create();
-      let is = mrs.rooms.len();
-      assert!(was+1 == is, "was {} rooms, want {} rooms, got {} rooms", was, was+1, is);
-   }
-
-   #[test]
-   fn join_404() {
-      let mrs = _dummy();
-      let was = mrs.rooms.len();
-      let r = mrs.join("does not exist".to_string());
-      let is = mrs.rooms.len();
-      assert!(was == is, "was {} rooms, want {} rooms, got {} rooms", was, was+1, is);
-      assert!(!r.is_ok());
-   }
-
-   #[test]
-   fn join_found() {
-      let mrs = _dummy();
-      let was = mrs.rooms.len();
-      let r = mrs.join("0".to_string());
-      let is = mrs.rooms.len();
-      assert!(was == is, "was {} rooms, want {} rooms, got {} rooms", was, was+1, is);
-      assert!(r.is_ok());
-      assert!(r.ok().unwrap().room_id() == "0");
-   }
-
-   #[test]
-   fn join_clobber() {
-      let mrs = _dummy();
-      let mut a = mrs.join("0".to_string()).ok().unwrap();
-      let mut b = mrs.join("0".to_string()).ok().unwrap();
-      assert!(a.room_id() == b.room_id());
-      assert!(a.sync().len() == b.sync().len());
-      assert!(a.sync().len() == b.sync().len());
-      assert!(a.sync().len() == 0);
-      assert!(b.sync().len() == 0);
-      assert!(a.send("from a".to_string()).is_ok());
-      assert!(a.sync().len() == 1);
-      assert!(b.sync().len() == 1);
-      assert!(b.send("from b".to_string()).is_ok());
-      assert!(b.send("from b".to_string()).is_ok());
-      assert!(a.sync().len() == 2);
-      assert!(b.sync().len() == 2);
-      assert!(a.send("from a".to_string()).is_ok());
-      assert!(b.send("from b".to_string()).is_ok());
-      assert!(a.send("from a".to_string()).is_ok());
-      assert!(a.sync().len() == 3);
-      assert!(b.sync().len() == 3);
-      assert!(a.send("from a".to_string()).is_ok());
-      assert!(b.send("from b".to_string()).is_ok());
-      let a = a.sync();
-      let b = b.sync();
-      assert!(a.len() == 2);
-      assert!(b.len() == 2);
-      assert!(a[0].body == "from a");
-      assert!(b[0].body == "from a");
-      assert!(a[1].body == "from b");
-      assert!(b[1].body == "from b");
-   }
-}

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

@@ -1,5 +0,0 @@
-mod event;
-mod room;
-mod rooms;
-mod mockroom;
-mod mockrooms;

secert-hitler/src/controller/state/room.rs

@@ -1,22 +0,0 @@
-use super::event;
-
-pub trait Room {
-   fn sync(&mut self) -> Vec<event::Event>;
-   fn send(&mut self, message: String) -> Result<&str, &str>;
-   fn room_id(&self) -> String;
-}
-
-#[cfg(test)]
-mod tests {
-   use super::Room;
-   use super::super::mockroom::MockRoom;
-
-   #[test]
-   fn mockroom() {
-      fn gen() -> impl Room {
-         let r = MockRoom::create();
-         r
-      }
-      gen();
-   }
-}

secert-hitler/src/controller/state/rooms.rs

@@ -1,21 +0,0 @@
-use super::room::Room;
-
-pub trait Rooms {
-   fn create(&mut self) -> Box<dyn Room>;
-   fn join(&self, room_id: String) -> Result<Box<dyn Room>, &str>;
-}
-
-#[cfg(test)]
-mod tests {
-   use super::Rooms;
-   use super::super::mockrooms::MockRooms;
-
-   #[test]
-   fn mockrooms() {
-      fn gen() -> impl Rooms {
-         let r = MockRooms::new();
-         r
-      }
-      gen();
-   }
-}