oshatori

A versatile multi-protocol chat library

[!WARNING] This library is in its early stages and the core structure will evolve as more protocols are implemented. If you're still considering contributing at this point in time, make sure to look out for a more stable release of oshatori before sending a pull request.

[!WARNING] README is currently out of date.

Introduction

This project aims to generalize a broad range of text chat and social interactions. To start off let's go over the types provided by the library:

Common interface trait called Connection:

pub trait Connection: Send + Sync {
    async fn connect(&mut self, auth: Vec<AuthField>) -> Result<(), String>;
    async fn disconnect(&mut self) -> Result<(), String>;
    async fn send(&mut self, event: ConnectionEvent) -> Result<(), String>;
    fn subscribe(&self) -> broadcast::Receiver<ConnectionEvent>;
    fn protocol_spec() -> Protocol;
}

Every implemented protocol can be interacted with using this interface, and the same set of events:

Example

Here is an example straight from the mock_connection.rs test:

use chrono::Utc;
use oshatori::{
    connection::{ChatEvent, ConnectionEvent, MockConnection},
    Connection, Message, MessageFragment, MessageStatus, MessageType,
};

#[tokio::test]
async fn test_mock_connection_integration() {
    let mut conn = MockConnection::new();
    let mut rx = conn.subscribe();

    let test_message = Message {
        id: None,
        sender_id: None,
        content: vec![MessageFragment::Text("some text".to_string())],
        timestamp: Utc::now(),
        message_type: MessageType::Normal,
        status: MessageStatus::Sent,
    };

    conn.send(ConnectionEvent::Chat {
        event: ChatEvent::New {
            channel_id: None,
            message: test_message.clone(),
        },
    })
    .await
    .expect("failed to send");

    let received = rx.recv().await.expect("failed to receive");

    if let ConnectionEvent::Chat { event } = received {
        if let ChatEvent::New {
            channel_id,
            message,
        } = event
        {
            assert_eq!(channel_id, None);
            match message.content.get(0) {
                Some(fragment) => match fragment {
                    MessageFragment::Text(value) => {
                        assert_eq!(value.to_owned(), "some text".to_string())
                    }
                    _ => {}
                },
                None => {}
            }
        } else {
            panic!("unexpected chat event");
        }
    } else {
        panic!("unexpected connection event");
    }
}

Coverage

Currently these protocols are implemented:

• sockchat - using kanii-lib
• mock - a mock protocol for testing

Styleguide

The folder structure is used as follows:

• src
  • connection - protocol implementations
    • mod.rs - Connection trait definition
    • sockchat.rs
    • mock.rs
  • utils - helper functions used by multiple protocols
    • bbcode.rs - bbcode parser
    • color.rs - kanii_to_rgba
    • html.rs - replacing <, >, and \s<br/>\s with <, >, and \n
    • mod.rs
  • lib.rs - type definitions
• tests - tests for each protocol
  • mock_connection.rs
  • sockchat_connection