Refactor macro

sje/tests/array_of_objects.rs

@@ -39,3 +39,50 @@ fn should_decode_array_of_objects() {
 
     assert!(positions.next().is_none());
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn should_handle_empty_updates() {
+        let json = r#"{"t":1746699621,"u":[]}"#;
+        let update = PositionUpdateDecoder::decode(json.as_bytes()).unwrap();
+        assert_eq!(0, update.updates_count());
+        let mut positions = update.updates().into_iter();
+        assert!(positions.next().is_none());
+    }
+
+    #[test]
+    fn should_handle_single_update() {
+        let json = r#"{"t":1746699621,"u":[{"s":"bnbusdt","a":50}]}"#;
+        let update = PositionUpdateDecoder::decode(json.as_bytes()).unwrap();
+        assert_eq!(1, update.updates_count());
+
+        let mut positions = update.updates().into_iter();
+        let position = positions.next().unwrap();
+        assert_eq!("bnbusdt", position.symbol_as_str());
+        assert_eq!(50, position.amount());
+        assert!(positions.next().is_none());
+    }
+
+    #[test]
+    fn should_decode_array_of_objects() {
+        let json = r#"{"t":1746699621,"u":[{"s":"btcusdt","a":100},{"s":"ethusdt","a":200}]}"#;
+
+        let update = PositionUpdateDecoder::decode(json.as_bytes()).unwrap();
+        assert_eq!(2, update.updates_count());
+
+        let mut positions = update.updates().into_iter();
+
+        let position = positions.next().unwrap();
+        assert_eq!("btcusdt", position.symbol_as_str());
+        assert_eq!(100, position.amount());
+
+        let position = positions.next().unwrap();
+        assert_eq!("ethusdt", position.symbol_as_str());
+        assert_eq!(200, position.amount());
+
+        assert!(positions.next().is_none());
+    }
+}

sje/tests/custom.rs

@@ -20,11 +20,47 @@ pub struct Trade {
     price: Price,
 }
 
-#[test]
-fn should_parse_custom_field() {
-    let json = r#"{"p":"12345"}"#;
-    let trade = TradeDecoder::decode(json.as_bytes()).unwrap();
-    assert_eq!(&Price(12345), trade.price_as_lazy_field().get_ref().unwrap());
-    assert_eq!(Price(12345), trade.price_as_lazy_field().get().unwrap());
-    assert_eq!(Price(12345), trade.price());
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn should_parse_custom_field() {
+        let json = r#"{"p":"12345"}"#;
+        let trade = TradeDecoder::decode(json.as_bytes()).unwrap();
+        assert_eq!(&Price(12345), trade.price_as_lazy_field().get_ref().unwrap());
+        assert_eq!(Price(12345), trade.price_as_lazy_field().get().unwrap());
+        assert_eq!(Price(12345), trade.price());
+    }
+
+    #[test]
+    fn should_parse_zero_price() {
+        let json = r#"{"p":"0"}"#;
+        let trade = TradeDecoder::decode(json.as_bytes()).unwrap();
+        assert_eq!(Price(0), trade.price());
+    }
+
+    #[test]
+    fn should_parse_large_price() {
+        let json = r#"{"p":"9876543210"}"#;
+        let trade = TradeDecoder::decode(json.as_bytes()).unwrap();
+        assert_eq!(Price(9876543210), trade.price());
+    }
+
+    #[test]
+    fn should_handle_multiple_trades() {
+        let trades_json = [r#"{"p":"100"}"#, r#"{"p":"200"}"#, r#"{"p":"300"}"#];
+
+        for (i, json) in trades_json.iter().enumerate() {
+            let trade = TradeDecoder::decode(json.as_bytes()).unwrap();
+            assert_eq!(Price(((i + 1) * 100) as u64), trade.price());
+        }
+    }
+
+    #[test]
+    fn should_parse_price_with_leading_zeros() {
+        let json = r#"{"p":"000012345"}"#;
+        let trade = TradeDecoder::decode(json.as_bytes()).unwrap();
+        assert_eq!(Price(12345), trade.price());
+    }
 }

sje/tests/decoder.rs

@@ -26,6 +26,32 @@ pub struct Trade {
     is_buyer_maker: bool,
 }
 
+#[derive(Decoder)]
+#[sje(object)]
+#[allow(dead_code)]
+pub struct AggTrade {
+    #[sje(rename = "e", len = 8)]
+    event_type: String,
+    #[sje(rename = "E", len = 13)]
+    event_time: u64,
+    #[sje(rename = "s")]
+    symbol: String,
+    #[sje(rename = "t", len = 10)]
+    trade_id: u64,
+    #[sje(rename = "p")]
+    price: String,
+    #[sje(rename = "q")]
+    quantity: String,
+    #[sje(rename = "b", len = 11)]
+    buyer_order_id: u64,
+    #[sje(rename = "a", len = 11)]
+    seller_order_id: u64,
+    #[sje(rename = "T", len = 13)]
+    transaction_time: u64,
+    #[sje(rename = "m")]
+    is_buyer_maker: bool,
+}
+
 #[derive(Decoder, Debug)]
 #[sje(object)]
 #[allow(dead_code)]
@@ -40,7 +66,8 @@ struct ListenKeyExpired {
 
 #[cfg(test)]
 mod tests {
-    use crate::{ListenKeyExpiredDecoder, Trade, TradeDecoder};
+    use crate::{AggTradeDecoder, ListenKeyExpiredDecoder, Trade, TradeDecoder};
+    use sje_derive::Decoder;
     use std::str::from_utf8_unchecked;
 
     #[test]
@@ -71,4 +98,65 @@ mod tests {
         assert_eq!(1743606297156, listen_key_expired.event_time());
         assert_eq!("FdffIUjdfd343DtLMw2tKS87iL2HpYRniDWpkoxWCb4fwP2yzJXalBlBNnz471cE", listen_key_expired.listen_key());
     }
+
+    #[test]
+    fn should_decode_agg_trade() {
+        let agg_trade = AggTradeDecoder::decode(br#"{"e":"aggTrade","E":1705085312570,"s":"ETHUSDT","a":12345678,"p":"1850.00000000","q":"0.00500000","f":1000001,"l":1000001,"T":1705085312570,"m":false,"M":true}"#).unwrap();
+        assert_eq!("aggTrade", agg_trade.event_type());
+        assert_eq!("ETHUSDT", agg_trade.symbol());
+    }
+
+    #[test]
+    fn should_decode_kline_event() {
+        #[derive(Decoder)]
+        #[sje(object)]
+        #[allow(dead_code)]
+        struct Kline {
+            #[sje(rename = "e")]
+            event_type: String,
+            #[sje(rename = "E")]
+            event_time: u64,
+            #[sje(rename = "s")]
+            symbol: String,
+            #[sje(rename = "k")]
+            kline: String,
+        }
+
+        let kline_msg =
+            KlineDecoder::decode(br#"{"e":"kline","E":1705085313000,"s":"BNBUSDT","k":"simplified"}"#).unwrap();
+        assert_eq!("kline", kline_msg.event_type());
+        assert_eq!("BNBUSDT", kline_msg.symbol());
+        assert_eq!("simplified", kline_msg.kline());
+    }
+
+    #[test]
+    fn should_decode_24hr_ticker() {
+        #[derive(Decoder)]
+        #[sje(object)]
+        #[allow(dead_code)]
+        struct Ticker24hr {
+            #[sje(rename = "e")]
+            event_type: String,
+            #[sje(rename = "E")]
+            event_time: u64,
+            #[sje(rename = "s")]
+            symbol: String,
+            #[sje(rename = "c")]
+            close_price: String,
+            #[sje(rename = "h")]
+            high_price: String,
+            #[sje(rename = "l")]
+            low_price: String,
+        }
+
+        let ticker_msg = Ticker24hrDecoder::decode(
+            br#"{"e":"24hrTicker","E":1705085314000,"s":"BNBUSDT","c":"350.50","h":"355.00","l":"345.00"}"#,
+        )
+        .unwrap();
+        assert_eq!("24hrTicker", ticker_msg.event_type());
+        assert_eq!("BNBUSDT", ticker_msg.symbol());
+        assert_eq!("350.50", ticker_msg.close_price());
+        assert_eq!("355.00", ticker_msg.high_price());
+        assert_eq!("345.00", ticker_msg.low_price());
+    }
 }

sje/tests/iter.rs

@@ -114,4 +114,43 @@ mod tests {
         assert_eq!(Some((Price(2.6468), Quantity(22540.8))), asks.next());
         assert_eq!(None, asks.next());
     }
+
+    #[test]
+    fn should_handle_empty_bids_or_asks() {
+        // Empty bids
+        let json = br#"{"e":"depthUpdate","b":[],"a":[["2.5","100"]]}"#;
+        let update = L2UpdateDecoder::decode(json).unwrap();
+        assert_eq!(0, update.bids_count());
+        assert_eq!(1, update.asks_count());
+
+        let mut bids = update.bids().into_iter();
+        assert_eq!(None, bids.next());
+
+        let mut asks = update.asks().into_iter();
+        assert_eq!(Some((Price(2.5), Quantity(100.0))), asks.next());
+        assert_eq!(None, asks.next());
+
+        // Empty asks
+        let json = br#"{"e":"depthUpdate","b":[["1.5","50"]],"a":[]}"#;
+        let update = L2UpdateDecoder::decode(json).unwrap();
+        assert_eq!(1, update.bids_count());
+        assert_eq!(0, update.asks_count());
+
+        let mut bids = update.bids().into_iter();
+        assert_eq!(Some((Price(1.5), Quantity(50.0))), bids.next());
+        assert_eq!(None, bids.next());
+
+        let mut asks = update.asks().into_iter();
+        assert_eq!(None, asks.next());
+    }
+
+    #[test]
+    fn should_convert_to_owned_with_empty_arrays() {
+        let json = br#"{"e":"depthUpdate","b":[],"a":[]}"#;
+        let update: L2Update = L2UpdateDecoder::decode(json).unwrap().into();
+
+        assert_eq!("depthUpdate", update.event_type);
+        assert!(update.bids.is_empty());
+        assert!(update.asks.is_empty());
+    }
 }

sje_derive/src/attribute.rs

@@ -0,0 +1,121 @@
+use proc_macro2::Span;
+use std::str::FromStr;
+use syn::{
+    Ident, LitBool, LitInt, LitStr, Token,
+    parse::{Parse, ParseStream},
+};
+
+#[derive(Debug, Copy, Clone)]
+#[allow(dead_code)]
+pub enum SjeType {
+    Object,
+    Array,
+    Tuple,
+    Union,
+}
+
+impl FromStr for SjeType {
+    type Err = syn::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "object" => Ok(SjeType::Object),
+            "array" => Ok(SjeType::Array),
+            "tuple" => Ok(SjeType::Tuple),
+            "union" => Ok(SjeType::Union),
+            _ => Err(syn::Error::new(Span::call_site(), "expected 'object', 'array', 'tuple' or 'union'")),
+        }
+    }
+}
+
+#[derive(Copy, Clone)]
+#[allow(dead_code)]
+pub struct SjeAttribute {
+    pub sje_type: SjeType,
+}
+
+impl Parse for SjeAttribute {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        let ident: Ident = input.parse()?;
+        let sje_type = ident.to_string().parse()?;
+        Ok(SjeAttribute { sje_type })
+    }
+}
+
+#[derive(Debug, Clone)]
+#[allow(dead_code)]
+pub struct SjeFieldAttribute {
+    #[allow(dead_code)]
+    /// value length
+    pub len: Option<usize>,
+    /// field name override
+    pub name: Option<String>,
+    /// json type name override
+    pub ty: Option<String>,
+    /// additional conversion method
+    pub also_as: Option<String>,
+    /// offset at which value begins
+    pub offset: usize,
+    pub decoder: bool,
+}
+
+impl Parse for SjeFieldAttribute {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        let mut len = None;
+        let mut name = None;
+        let mut ty = None;
+        let mut also_as = None;
+        let mut offset = 0;
+        let mut decoder = false;
+
+        while !input.is_empty() {
+            let lookahead = input.lookahead1();
+            if lookahead.peek(Ident) {
+                let ident: Ident = input.parse()?;
+                if ident == "len" {
+                    input.parse::<Token![=]>()?;
+                    let len_lit: LitInt = input.parse()?;
+                    len = Some(len_lit.base10_parse()?);
+                } else if ident == "rename" {
+                    input.parse::<Token![=]>()?;
+                    let ref_lit: LitStr = input.parse()?;
+                    name = Some(ref_lit.value());
+                } else if ident == "ty" {
+                    input.parse::<Token![=]>()?;
+                    let ty_lit: LitStr = input.parse()?;
+                    ty = Some(ty_lit.value());
+                } else if ident == "also_as" {
+                    input.parse::<Token![=]>()?;
+                    let as_lit: LitStr = input.parse()?;
+                    also_as = Some(as_lit.value());
+                } else if ident == "offset" {
+                    input.parse::<Token![=]>()?;
+                    let offset_lit: LitInt = input.parse()?;
+                    offset = offset_lit.base10_parse()?;
+                } else if ident == "decoder" {
+                    input.parse::<Token![=]>()?;
+                    let decoder_lit: LitBool = input.parse()?;
+                    decoder = decoder_lit.value();
+                } else {
+                    return Err(syn::Error::new_spanned(ident, "expected ['len' | 'rename' | 'ty']"));
+                }
+            } else {
+                return Err(lookahead.error());
+            }
+
+            // Optional comma
+            if input.peek(Token![,]) {
+                input.parse::<Token![,]>()?;
+            }
+        }
+
+        Ok(SjeFieldAttribute {
+            len,
+            name,
+            ty,
+            also_as,
+            offset,
+            decoder,
+        })
+    }
+}

sje_derive/src/enums.rs

@@ -0,0 +1,18 @@
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::DataEnum;
+
+pub fn handle_enum(name: &syn::Ident, data_enum: DataEnum) -> TokenStream {
+    let variants = data_enum.variants.iter().map(|v| &v.ident);
+    let generated = quote! {
+        impl From<&[u8]> for #name {
+            fn from(bytes: &[u8]) -> Self {
+                match std::str::from_utf8(bytes).unwrap() {
+                    #( stringify!(#variants) => #name::#variants, )*
+                    _ => panic!("unrecognized side"),
+                }
+            }
+        }
+    };
+    generated
+}