initial commit

exercises/07_threads/10_patch/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "patch"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+thiserror = "1.0.59"
+ticket_fields = { path = "../../../helpers/ticket_fields" }

exercises/07_threads/10_patch/src/data.rs

@@ -0,0 +1,31 @@
+use crate::store::TicketId;
+use ticket_fields::{TicketDescription, TicketTitle};
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Ticket {
+    pub id: TicketId,
+    pub title: TicketTitle,
+    pub description: TicketDescription,
+    pub status: Status,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct TicketDraft {
+    pub title: TicketTitle,
+    pub description: TicketDescription,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct TicketPatch {
+    pub id: TicketId,
+    pub title: Option<TicketTitle>,
+    pub description: Option<TicketDescription>,
+    pub status: Option<Status>,
+}
+
+#[derive(Clone, Debug, Copy, PartialEq, Eq)]
+pub enum Status {
+    ToDo,
+    InProgress,
+    Done,
+}

exercises/07_threads/10_patch/src/lib.rs

@@ -0,0 +1,97 @@
+use std::sync::mpsc::{sync_channel, Receiver, SyncSender};
+
+// TODO: Implement the patching functionality.
+use crate::data::{Ticket, TicketDraft, TicketPatch};
+use crate::store::{TicketId, TicketStore};
+
+pub mod data;
+pub mod store;
+
+#[derive(Clone)]
+pub struct TicketStoreClient {
+    sender: SyncSender<Command>,
+}
+
+impl TicketStoreClient {
+    pub fn insert(&self, draft: TicketDraft) -> Result<TicketId, OverloadedError> {
+        let (response_sender, response_receiver) = sync_channel(1);
+        self.sender
+            .try_send(Command::Insert {
+                draft,
+                response_channel: response_sender,
+            })
+            .map_err(|_| OverloadedError)?;
+        Ok(response_receiver.recv().unwrap())
+    }
+
+    pub fn get(&self, id: TicketId) -> Result<Option<Ticket>, OverloadedError> {
+        let (response_sender, response_receiver) = sync_channel(1);
+        self.sender
+            .try_send(Command::Get {
+                id,
+                response_channel: response_sender,
+            })
+            .map_err(|_| OverloadedError)?;
+        Ok(response_receiver.recv().unwrap())
+    }
+
+    pub fn update(&self, ticket_patch: TicketPatch) -> Result<(), OverloadedError> {}
+}
+
+#[derive(Debug, thiserror::Error)]
+#[error("The store is overloaded")]
+pub struct OverloadedError;
+
+pub fn launch(capacity: usize) -> TicketStoreClient {
+    let (sender, receiver) = sync_channel(capacity);
+    std::thread::spawn(move || server(receiver));
+    TicketStoreClient { sender }
+}
+
+enum Command {
+    Insert {
+        draft: TicketDraft,
+        response_channel: SyncSender<TicketId>,
+    },
+    Get {
+        id: TicketId,
+        response_channel: SyncSender<Option<Ticket>>,
+    },
+    Update {
+        patch: TicketPatch,
+        response_channel: SyncSender<()>,
+    },
+}
+
+pub fn server(receiver: Receiver<Command>) {
+    let mut store = TicketStore::new();
+    loop {
+        match receiver.recv() {
+            Ok(Command::Insert {
+                draft,
+                response_channel,
+            }) => {
+                let id = store.add_ticket(draft);
+                let _ = response_channel.send(id);
+            }
+            Ok(Command::Get {
+                id,
+                response_channel,
+            }) => {
+                let ticket = store.get(id);
+                let _ = response_channel.send(ticket.cloned());
+            }
+            Ok(Command::Update {
+                patch,
+                response_channel,
+            }) => {
+                todo!()
+            }
+            Err(_) => {
+                // There are no more senders, so we can safely break
+                // and shut down the server.
+                break;
+            }
+        }
+    }
+}

exercises/07_threads/10_patch/src/store.rs

@@ -0,0 +1,41 @@
+use crate::data::{Status, Ticket, TicketDraft};
+use std::collections::BTreeMap;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct TicketId(u64);
+
+#[derive(Clone)]
+pub struct TicketStore {
+    tickets: BTreeMap<TicketId, Ticket>,
+    counter: u64,
+}
+
+impl TicketStore {
+    pub fn new() -> Self {
+        Self {
+            tickets: BTreeMap::new(),
+            counter: 0,
+        }
+    }
+
+    pub fn add_ticket(&mut self, ticket: TicketDraft) -> TicketId {
+        let id = TicketId(self.counter);
+        self.counter += 1;
+        let ticket = Ticket {
+            id,
+            title: ticket.title,
+            description: ticket.description,
+            status: Status::ToDo,
+        };
+        self.tickets.insert(id, ticket);
+        id
+    }
+
+    pub fn get(&self, id: TicketId) -> Option<&Ticket> {
+        self.tickets.get(&id)
+    }
+
+    pub fn get_mut(&mut self, id: TicketId) -> Option<&mut Ticket> {
+        self.tickets.get_mut(&id)
+    }
+}

exercises/07_threads/10_patch/tests/check.rs

@@ -0,0 +1,31 @@
+use patch::data::{Status, TicketDraft, TicketPatch};
+use patch::launch;
+use ticket_fields::test_helpers::{ticket_description, ticket_title};
+
+#[test]
+fn works() {
+    let client = launch(5);
+    let draft = TicketDraft {
+        title: ticket_title(),
+        description: ticket_description(),
+    };
+    let ticket_id = client.insert(draft.clone()).unwrap();
+
+    let ticket = client.get(ticket_id).unwrap().unwrap();
+    assert_eq!(ticket_id, ticket.id);
+    assert_eq!(ticket.status, Status::ToDo);
+    assert_eq!(ticket.title, draft.title);
+    assert_eq!(ticket.description, draft.description);
+
+    let patch = TicketPatch {
+        id: ticket_id,
+        title: None,
+        description: None,
+        status: Some(Status::InProgress),
+    };
+    client.update(patch).unwrap();
+
+    let ticket = client.get(ticket_id).unwrap().unwrap();
+    assert_eq!(ticket.id, ticket_id);
+    assert_eq!(ticket.status, Status::InProgress);
+}