Refactor data buffer type to include internal buffers

data/src/buffer.rs

@@ -6,34 +6,64 @@ use crate::user::Nick;
 use crate::{channel, config, message, Server};
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(untagged)]
 pub enum Buffer {
+ Upstream(Upstream),
+ Internal(Internal),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum Upstream {
  Server(Server),
  Channel(Server, String),
  Query(Server, Nick),
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, strum::Display)]
+pub enum Internal {
+ #[strum(serialize = "File Transfers")]
+ FileTransfers,
+ Logs,
+ Highlights,
+}
+
 impl Buffer {
+ pub fn upstream(&self) -> Option<&Upstream> {
+ if let Self::Upstream(upstream) = self {
+ Some(upstream)
+ } else {
+ None
+ }
+ }
+
+ pub fn internal(&self) -> Option<&Internal> {
+ if let Self::Internal(internal) = self {
+ Some(internal)
+ } else {
+ None
+ }
+ }
+}
+
+impl Upstream {
  pub fn server(&self) -> &Server {
  match self {
- Buffer::Server(server) | Buffer::Channel(server, _) | Buffer::Query(server, _) => {
- server
- }
+ Self::Server(server) | Self::Channel(server, _) | Self::Query(server, _) => server,
  }
  }
 
  pub fn channel(&self) -> Option<&str> {
  match self {
- Buffer::Server(_) => None,
- Buffer::Channel(_, channel) => Some(channel),
- Buffer::Query(_, _) => None,
+ Self::Channel(_, channel) => Some(channel),
+ Self::Server(_) | Self::Query(_, _) => None,
  }
  }
 
  pub fn target(&self) -> Option<String> {
  match self {
- Buffer::Server(_) => None,
- Buffer::Channel(_, channel) => Some(channel.clone()),
- Buffer::Query(_, nick) => Some(nick.to_string()),
+ Self::Channel(_, channel) => Some(channel.clone()),
+ Self::Query(_, nick) => Some(nick.to_string()),
+ Self::Server(_) => None,
  }
  }
 
@@ -55,6 +85,10 @@ impl Buffer {
  }
 }
 
+impl Internal {
+ pub const ALL: &'static [Self] = &[Self::FileTransfers, Self::Logs, Self::Highlights];
+}
+
 #[derive(Debug, Clone, Default, Deserialize, Serialize)]
 pub struct Settings {
  pub channel: channel::Settings,

data/src/client.rs

@@ -10,7 +10,7 @@ use crate::history::ReadMarker;
 use crate::message::server_time;
 use crate::time::Posix;
 use crate::user::{Nick, NickRef};
-use crate::{config, ctcp, dcc, isupport, message, mode, Buffer, Server, User};
+use crate::{buffer, config, ctcp, dcc, isupport, message, mode, Server, User};
 use crate::{file_transfer, server};
 
 const HIGHLIGHT_BLACKOUT_INTERVAL: Duration = Duration::from_secs(5);
@@ -99,7 +99,7 @@ pub struct Client {
  users: HashMap<String, Vec<User>>,
  labels: HashMap<String, Context>,
  batches: HashMap<String, Batch>,
- reroute_responses_to: Option<Buffer>,
+ reroute_responses_to: Option<buffer::Upstream>,
  registration_step: RegistrationStep,
  listed_caps: Vec<String>,
  supports_labels: bool,
@@ -188,7 +188,7 @@ impl Client {
  }
  }
 
- fn send(&mut self, buffer: &Buffer, mut message: message::Encoded) {
+ fn send(&mut self, buffer: &buffer::Upstream, mut message: message::Encoded) {
  if self.supports_labels {
  use proto::Tag;
 
@@ -1471,7 +1471,7 @@ impl Map {
  }
  }
 
- pub fn send(&mut self, buffer: &Buffer, message: message::Encoded) {
+ pub fn send(&mut self, buffer: &buffer::Upstream, message: message::Encoded) {
  if let Some(client) = self.client_mut(buffer.server()) {
  client.send(buffer, message);
  }
@@ -1588,12 +1588,12 @@ impl Map {
 
 #[derive(Debug, Clone)]
 pub enum Context {
- Buffer(Buffer),
- Whois(Buffer),
+ Buffer(buffer::Upstream),
+ Whois(buffer::Upstream),
 }
 
 impl Context {
- fn new(message: &message::Encoded, buffer: Buffer) -> Self {
+ fn new(message: &message::Encoded, buffer: buffer::Upstream) -> Self {
  if let Command::WHOIS(_, _) = message.command {
  Self::Whois(buffer)
  } else {
@@ -1605,7 +1605,7 @@ impl Context {
  matches!(self, Self::Whois(_))
  }
 
- fn buffer(self) -> Buffer {
+ fn buffer(self) -> buffer::Upstream {
  match self {
  Context::Buffer(buffer) => buffer,
  Context::Whois(buffer) => buffer,

data/src/command.rs

@@ -4,7 +4,7 @@ use irc::proto;
 use itertools::Itertools;
 use regex::Regex;
 
-use crate::{ctcp, message::formatting, Buffer};
+use crate::{buffer, ctcp, message::formatting};
 
 #[derive(Debug, Clone, Copy)]
 pub enum Kind {
@@ -66,7 +66,7 @@ pub enum Command {
  Unknown(String, Vec<String>),
 }
 
-pub fn parse(s: &str, buffer: Option<&Buffer>) -> Result<Command, Error> {
+pub fn parse(s: &str, buffer: Option<&buffer::Upstream>) -> Result<Command, Error> {
  let (head, rest) = s.split_once('/').ok_or(Error::MissingSlash)?;
  // Don't allow leading whitespace before slash
  if !head.is_empty() {