From b7bb9b131056c5ffc0552e6c2c16e52781558df7 Mon Sep 17 00:00:00 2001
From: Till Hoeppner
Date: Fri, 26 Jun 2015 16:58:52 +0200
Subject: Re-add carboxyl, split into owned and shared client

---
 Cargo.toml    |  4 ++-
 src/client.rs | 88 ++++++++++++++++++++++++++++++++++++++++++-----------------
 src/lib.rs    |  1 +
 3 files changed, 67 insertions(+), 26 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 4cb462e..d7f2c09 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,7 +13,6 @@ license = "MIT"
 log = "*"
 regex = "*"
 regex_macros = "*"
-carboxyl = "*"
 
 [features]
 ssl = ["openssl"]
@@ -23,6 +22,9 @@ lints = ["clippy"]
 version = "*"
 optional = true
 
+[dependencies.carboxyl]
+git = "https://github.com/tilpner/carboxyl"
+
 [dependencies.clippy]
 version = "*"
 optional = true
diff --git a/src/client.rs b/src/client.rs
index 55ec101..e548a83 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -8,8 +8,9 @@ use std::io::{
 
 use std::net::TcpStream;
 use std::borrow::Cow::{ self, Borrowed, Owned };
+use std::sync::{ Arc, Mutex };
 
-//use carboxyl::{ Stream, Sink };
+use carboxyl::{ Stream, Sink };
 
 use message::Message;
 use command::Command;
@@ -56,16 +57,37 @@ impl Read for StreamKind {
     }
 }
 
-pub struct Client {
+pub trait Client {
+    fn send_message(&mut self, msg: Message) -> Result<()>;
+    fn join(&mut self, channel: &str, password: Option<&str>) -> Result<()> {
+        self.send_message(JOIN(vec![channel.into()], password.iter().map(|&p| p.into()).collect()).to_message())
+    }
+
+    fn msg(&mut self, to: &str, message: &str) -> Result<()> {
+        self.send_message(PRIVMSG(to.into(), message.into()).to_message())
+    }
+
+    fn register(&mut self, nick: &str, user: &str, desc: &str, pass: Option<&str>) -> Result<()> {
+        Result(if let Some(pass) = pass {
+            self.send_message(PASS(pass.into()).to_message()).inner()
+        } else { Ok(()) }
+            .and_then(|_| self.send_message(NICK(nick.into()).to_message()).inner())
+            .and_then(|_| self.send_message(USER(user.into(), Borrowed("0"), Borrowed("*"), desc.into()).to_message()).inner())
+        )
+    }
+
+}
+
+pub struct OwnedClient {
     stream: Option<StreamKind>,
-//    sink: Sink<Message>
+    sink: Sink<Message>
 }
 
-impl Client {
-    pub fn new() -> Client {
-        Client {
+impl OwnedClient {
+    pub fn new() -> OwnedClient {
+        OwnedClient {
             stream: None,
-//            sink: Sink::new()
+            sink: Sink::new()
         }
     }
 
@@ -120,9 +142,6 @@ impl Client {
                                          .map_err(IrscError::Io)))
     }
 
-    pub fn send_message(&mut self, msg: Message) -> Result<()> {
-        self.send_raw(&msg.to_string())
-    }
 
     pub fn send(&mut self, cmd: Command) -> Result<()> {
         self.send_message(cmd.to_message())
@@ -157,7 +176,7 @@ impl Client {
                     on_event(self, &msg, event);
                 }
 
-                //self.sink.send(msg)
+                self.sink.send(msg)
             }
         }
         Result(Ok(()))
@@ -172,10 +191,35 @@ impl Client {
         self.intern_listen(Some(events))
     }
 
-//    pub fn messages(&self) -> Stream<Message> { self.sink.stream() }
+    pub fn into_shared(self) -> SharedClient {
+        SharedClient {
+            client: Arc::new(Mutex::new(self)),
+        }
+    }
+
+    pub fn messages(&self) -> Stream<Message> { self.sink.stream() }
+}
+
+impl Client for OwnedClient {
+    fn send_message(&mut self, msg: Message) -> Result<()> {
+        self.send_raw(&msg.to_string())
+    }
+}
+
+#[derive(Clone)]
+pub struct SharedClient {
+    client: Arc<Mutex<OwnedClient>>,
+}
+
+impl SharedClient {
+    pub fn messages(&self) -> Stream<(Arc<Mutex<OwnedClient>>, Message)> {
+        let cl = self.client.clone();
+        self.client.lock().unwrap().messages()
+            .map(move |m| (cl.clone(), m))
+    }
 
     /*pub fn events(&self) -> Stream<(Message, Event)> {
-        self.messages().filter_map(|msg| match Command::from_message(&msg) {
+        self.client.lock().unwrap().messages().filter_map(|msg| match Command::from_message(&msg) {
             Some(m) => Some((msg, Event::Command(m.clone()))),
             None => match Reply::from_message(&msg) {
                 Some(r) => Some((msg, Event::Reply(r))),
@@ -187,18 +231,12 @@ impl Client {
 //    pub fn commands(&self) -> Stream<Command> {
 //        self.messages().filter_map(|msg| Command::from_message(&msg).map(|c| c.to_static()))
 //    }
+}
 
-    pub fn join(&mut self, channel: &str, password: Option<&str>) -> Result<()> {
-        self.send_message(JOIN(vec![channel.into()], password.iter().map(|&p| p.into()).collect()).to_message())
-    }
-
-    pub fn msg(&mut self, to: &str, message: &str) -> Result<()> {
-        self.send_message(PRIVMSG(to.into(), message.into()).to_message())
-    }
-
-    pub fn register(&mut self, nick: &str, user: &str, desc: &str) -> Result<()> {
-        Result(self.send_message(NICK(nick.into()).to_message()).inner()
-            .and_then(|_| self.send_message(USER(user.into(), Borrowed("0"), Borrowed("*"), desc.into()).to_message()).inner()))
-
+impl Client for SharedClient {
+    fn send_message(&mut self, msg: Message) -> Result<()> {
+        if let Ok(mut guard) = self.client.lock() {
+            guard.send_raw(&msg.to_string())
+        } else { Result(Ok(())) }
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index 168f137..c9dade4 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -10,6 +10,7 @@ extern crate regex;
 extern crate log;
 #[cfg(feature = "ssl")]
 extern crate openssl;
+extern crate carboxyl;
 
 pub mod client;
 pub mod color;
-- 
cgit v1.2.3