dyn_encoding/codec/

bebop.rs

//! `application/x-bebop` codec backed by the `bebop` runtime.
//!
//! Bebop is a binary, schema-first format generated by `bebopc`.
//! Like the FlatBuffers and Cap'n Proto codecs, this module avoids
//! the upstream code generator: each registered type provides its
//! own conversion through the [`BebopWire`] trait. Implementations
//! typically lean on the primitive `bebop::SubRecord` impls that
//! ship with the runtime (for `String`, `u32`, `Vec<u8>`, ...) so
//! that the fixture itself does not need to implement
//! `bebop::Record` directly.

use std::collections::HashMap;

use crate::error::CodecError;
use crate::value::{ErasedWireValue, WireCodec, WireTypeId, WireValue};

type EncodeFn =
    Box<dyn Fn(&dyn ErasedWireValue) -> Result<Vec<u8>, CodecError> + Send + Sync + 'static>;
type DecodeFn =
    Box<dyn Fn(&[u8]) -> Result<Box<dyn ErasedWireValue>, CodecError> + Send + Sync + 'static>;

/// Per-message-type Bebop encode/decode contract.
///
/// Implementors emit a Bebop-compatible byte stream (typically by
/// composing `bebop::SubRecord::_serialize_chained` calls on each
/// field) inside `bebop_encode`, and reverse the process in
/// `bebop_decode`.
pub trait BebopWire: WireValue + Sized {
    /// Serialise `self` into the Bebop wire format.
    fn bebop_encode(&self) -> Result<Vec<u8>, CodecError>;

    /// Parse a Bebop-encoded byte slice back into `Self`.
    fn bebop_decode(bytes: &[u8]) -> Result<Self, CodecError>;
}

/// Codec that serialises [`WireValue`] types as Bebop messages via
/// per-type [`BebopWire`] implementations.
#[derive(Default)]
pub struct BebopCodec {
    encoders: HashMap<WireTypeId, EncodeFn>,
    decoders: HashMap<WireTypeId, DecodeFn>,
}

impl BebopCodec {
    /// Construct an empty Bebop codec with no registered types.
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    /// Register a [`WireValue`] type with the codec.
    pub fn register<T>(&mut self) -> &mut Self
    where
        T: BebopWire + 'static,
    {
        let id = T::wire_type_id();
        self.encoders.insert(
            id,
            Box::new(
                move |v: &dyn ErasedWireValue| -> Result<Vec<u8>, CodecError> {
                    let concrete = v
                        .as_any()
                        .downcast_ref::<T>()
                        .ok_or(CodecError::TypeMismatch { expected: id })?;
                    concrete.bebop_encode()
                },
            ),
        );
        self.decoders.insert(
            id,
            Box::new(
                move |bytes: &[u8]| -> Result<Box<dyn ErasedWireValue>, CodecError> {
                    let value = T::bebop_decode(bytes)?;
                    Ok(Box::new(value))
                },
            ),
        );
        self
    }

    /// Number of message types registered with this codec.
    #[must_use]
    pub fn registered_type_count(&self) -> usize {
        self.encoders.len()
    }
}

impl WireCodec for BebopCodec {
    fn content_type(&self) -> &'static str {
        "application/x-bebop"
    }

    fn encode(&self, value: &dyn ErasedWireValue) -> Result<Vec<u8>, CodecError> {
        let id = value.type_id();
        let encoder = self
            .encoders
            .get(&id)
            .ok_or(CodecError::UnknownTypeId(id))?;
        encoder(value)
    }

    fn decode(
        &self,
        type_id: WireTypeId,
        bytes: &[u8],
    ) -> Result<Box<dyn ErasedWireValue>, CodecError> {
        let decoder = self
            .decoders
            .get(&type_id)
            .ok_or(CodecError::UnknownTypeId(type_id))?;
        decoder(bytes)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use ::bebop::SubRecord;

    /// Hand-rolled Bebop fixture. The schema, written out, is:
    ///
    /// ```text
    /// struct Sample {
    ///   string name;
    ///   uint32 seq;
    ///   byte[] payload;
    /// }
    /// ```
    ///
    /// The encoder/decoder compose the runtime's primitive
    /// `SubRecord` impls (`String`, `u32`, `Vec<u8>`) back to back,
    /// which is exactly the layout `bebopc` emits for a Bebop
    /// `struct`. No `unsafe` is required because the primitive
    /// `_serialize_chained` / `_deserialize_chained` methods are
    /// safe.
    #[derive(Debug, Eq, PartialEq)]
    struct Sample {
        name: String,
        seq: u32,
        payload: Vec<u8>,
    }

    impl WireValue for Sample {
        fn wire_type_id() -> WireTypeId {
            WireTypeId::new("test.bebop.Sample")
        }
    }

    impl BebopWire for Sample {
        fn bebop_encode(&self) -> Result<Vec<u8>, CodecError> {
            let mut buf = Vec::with_capacity(
                self.name.serialized_size()
                    + self.seq.serialized_size()
                    + self.payload.serialized_size(),
            );
            self.name
                ._serialize_chained(&mut buf)
                .map_err(CodecError::encode_failure)?;
            self.seq
                ._serialize_chained(&mut buf)
                .map_err(CodecError::encode_failure)?;
            self.payload
                ._serialize_chained(&mut buf)
                .map_err(CodecError::encode_failure)?;
            Ok(buf)
        }

        fn bebop_decode(bytes: &[u8]) -> Result<Self, CodecError> {
            let mut off = 0usize;
            let (n, name) = <String as SubRecord<'_>>::_deserialize_chained(&bytes[off..])
                .map_err(CodecError::decode_failure)?;
            off = off
                .checked_add(n)
                .ok_or_else(|| CodecError::decode_failure("bebop: cursor overflow"))?;
            let (n, seq) = <u32 as SubRecord<'_>>::_deserialize_chained(&bytes[off..])
                .map_err(CodecError::decode_failure)?;
            off = off
                .checked_add(n)
                .ok_or_else(|| CodecError::decode_failure("bebop: cursor overflow"))?;
            let (n, payload) = <Vec<u8> as SubRecord<'_>>::_deserialize_chained(&bytes[off..])
                .map_err(CodecError::decode_failure)?;
            let _ = off
                .checked_add(n)
                .ok_or_else(|| CodecError::decode_failure("bebop: cursor overflow"))?;
            Ok(Sample { name, seq, payload })
        }
    }

    fn fixture() -> Sample {
        Sample {
            name: "zeta".into(),
            seq: 0xdead_beef,
            payload: vec![0x00, 0x11, 0x22, 0x33],
        }
    }

    #[test]
    fn round_trip_recovers_value() {
        let mut codec = BebopCodec::new();
        codec.register::<Sample>();
        let v = fixture();
        let bytes = codec.encode(&v).expect("encode");
        let back = codec
            .decode(Sample::wire_type_id(), &bytes)
            .expect("decode");
        let back = back.as_any().downcast_ref::<Sample>().expect("downcast");
        assert_eq!(back, &v);
    }

    #[test]
    fn idempotent_encode_is_byte_equal() {
        let mut codec = BebopCodec::new();
        codec.register::<Sample>();
        let v = fixture();
        let a = codec.encode(&v).expect("encode 1");
        let b = codec.encode(&v).expect("encode 2");
        assert_eq!(a, b);
        let back = codec.decode(Sample::wire_type_id(), &a).expect("decode");
        let c = codec.encode(back.as_ref()).expect("encode 3");
        assert_eq!(a, c);
    }

    #[test]
    fn unregistered_type_returns_unknown_type_id_on_encode() {
        let codec = BebopCodec::new();
        let v = fixture();
        let err = codec.encode(&v).expect_err("expected unknown type");
        assert!(matches!(err, CodecError::UnknownTypeId(id) if id == Sample::wire_type_id()));
    }

    #[test]
    fn unregistered_type_returns_unknown_type_id_on_decode() {
        let codec = BebopCodec::new();
        let err = codec
            .decode(Sample::wire_type_id(), b"")
            .expect_err("expected unknown type");
        assert!(matches!(err, CodecError::UnknownTypeId(id) if id == Sample::wire_type_id()));
    }

    #[test]
    fn malformed_bytes_yield_decode_failure() {
        let mut codec = BebopCodec::new();
        codec.register::<Sample>();
        // Bebop strings are length-prefixed (u32 LE). Three bytes is
        // not enough to even read the length field.
        let err = codec
            .decode(Sample::wire_type_id(), &[0x01, 0x02, 0x03])
            .expect_err("expected decode failure");
        assert!(matches!(err, CodecError::Decode(_)));
    }
}